Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                

Dynamodb DG

Descargar como pdf o txt
Descargar como pdf o txt
Está en la página 1de 1266

Amazon DynamoDB

Guía para desarrolladores


Versión de API 2012-08-10
Amazon DynamoDB Guía para desarrolladores

Amazon DynamoDB: Guía para desarrolladores


Copyright © Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

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

Versión de API 2012-08-10


iii
Amazon DynamoDB Guía para desarrolladores

Paso 7: Consulta del índice secundario global .............................................................................. 79


Paso 8: (Opcional) Limpieza ....................................................................................................... 80
Pasos siguientes ....................................................................................................................... 81
Introducción aAWSSDK de ................................................................................................................. 82
Java y DynamoDB .................................................................................................................... 82
Requisitos previos del tutorial ............................................................................................. 82
Paso  1: Crear una tabla ..................................................................................................... 83
Paso 2: Carga de ejemplos de datos ................................................................................... 84
Paso 3: Creación, lectura, actualización y eliminación de elementos .......................................... 87
Paso 4: Consulta y examen de los datos .............................................................................. 96
Paso 5: (Opcional) Eliminar la tabla ................................................................................... 100
Summary ....................................................................................................................... 101
JavaScript y DynamoDB ........................................................................................................... 102
Requisitos previos del tutorial ........................................................................................... 102
Paso  1: Crear una tabla ................................................................................................... 103
Paso 2: Carga de ejemplos de datos ................................................................................. 105
Paso 3: Creación, lectura, actualización y ........................................................................... 107
Paso 4: Consultar y examinar los datos .............................................................................. 117
Paso 5: (Opcional): Eliminar la tabla .................................................................................. 122
Resumen ....................................................................................................................... 124
Node.js y DynamoDB .............................................................................................................. 124
Requisitos previos del tutorial ........................................................................................... 125
Paso  1: Crear una tabla ................................................................................................... 125
Paso 2: Carga de ejemplos de datos ................................................................................. 126
Paso 3: Creación, lectura, actualización y eliminación de elementos ........................................ 128
Paso 4: Consulta y análisis de datos .................................................................................. 136
Paso 5: (Opcional): Eliminar la tabla .................................................................................. 141
Summary ....................................................................................................................... 141
.NET y DynamoDB .................................................................................................................. 142
Requisitos previos del tutorial ........................................................................................... 143
Paso 1: Creación de un cliente ......................................................................................... 144
Paso  2: Crear una tabla ................................................................................................... 146
Paso  3: Carga de datos ................................................................................................... 148
Paso 4: Agregar una película ............................................................................................ 150
Paso  5: Leer una película ................................................................................................. 151
Paso 6: Actualización de la película ................................................................................... 152
Paso 7: Eliminación de un elemento con condiciones ........................................................... 154
Paso 8: Consulta una tabla .............................................................................................. 155
Paso 9: Examen de una tabla ........................................................................................... 157
Paso 10: Eliminar la tabla ................................................................................................ 159
PHP y DynamoDB .................................................................................................................. 159
Requisitos previos del tutorial ........................................................................................... 159
Paso  1: Crear una tabla ................................................................................................... 160
Paso 2: Carga de ejemplos de datos ................................................................................. 161
Paso 3: Crear, leer, actualizar y eliminar elementos .............................................................. 164
Paso 4: Consulta y examen de los datos ............................................................................ 173
Paso 5: (Opcional) Eliminar la tabla ................................................................................... 178
Summary ....................................................................................................................... 179
Python y DynamoDB ............................................................................................................... 180
Requisitos previos del tutorial ........................................................................................... 180
Paso  1: Crear una tabla ................................................................................................... 181
Paso 2: Carga de ejemplos de datos ................................................................................. 182
Paso 3: Operaciones de CRUD ......................................................................................... 184
Paso 4: Consulta y examen de los datos ............................................................................ 190
Paso 5: (Opcional) Eliminar la tabla ................................................................................... 193
Summary ....................................................................................................................... 194
Ruby y DynamoDB .................................................................................................................. 194

Versión de API 2012-08-10


iv
Amazon DynamoDB Guía para desarrolladores

Requisitos previos del tutorial ........................................................................................... 194


Paso  1: Crear una tabla ................................................................................................... 195
Paso 2: Carga de ejemplos de datos ................................................................................. 196
Paso 3: Creación, lectura, actualización y eliminación de elementos ........................................ 199
Paso 4: Consulta y examen de los datos ............................................................................ 207
Paso 5: (Opcional) Eliminar la tabla ................................................................................... 211
Summary ....................................................................................................................... 212
Programación con DynamoDB .......................................................................................................... 214
Información general deAWSSupport del SDK de con DynamoDB .................................................... 214
Interfaces de programación ...................................................................................................... 216
Interfaces de bajo nivel .................................................................................................... 217
Interfaces de documentos ................................................................................................ 218
Interfaz de persistencia de objetos ..................................................................................... 218
API de bajo nivel .................................................................................................................... 220
Formato de las solicitudes ................................................................................................ 222
Formato de respuesta ...................................................................................................... 222
Descriptores de tipos de datos .......................................................................................... 223
Datos numéricos ............................................................................................................. 224
Datos de tipo Binary ........................................................................................................ 224
Control de errores ................................................................................................................... 224
Componentes de un error ................................................................................................. 225
Mensajes y códigos de error ............................................................................................. 225
Control de errores en la aplicación .................................................................................... 228
Reintentos de error y retardo exponencial ........................................................................... 229
Operaciones por lotes y control de errores .......................................................................... 230
Interfaces de programación de nivel superior para DynamoDB ....................................................... 230
Java: DynamoDBMapper .................................................................................................. 231
.NET: Modelo de documento ............................................................................................ 279
.NET: Modelo de persistencia de objetos ............................................................................ 303
Ejecución de ejemplos de código .............................................................................................. 332
Carga de ejemplos de datos ............................................................................................. 333
Ejemplos de código Java ................................................................................................. 338
Ejemplos de código .NET ................................................................................................. 340
Trabajar con DynamoDB .................................................................................................................. 344
Uso de tablas ......................................................................................................................... 344
Operaciones básicas en tablas de ..................................................................................... 344
Consideraciones sobre el cambio del modo de capacidad de lectura/escritura ........................... 349
Tablas de capacidad aprovisionadas .................................................................................. 350
Tamaños y formatos de elementos .................................................................................... 354
Administración de la capacidad de desempeño con Auto Scaling ............................................ 355
Uso de tablas globales .................................................................................................... 370
Etiquetado de recursos de ................................................................................................ 394
Uso de tablas: Java ....................................................................................................... 398
Uso de tablas: .NET ........................................................................................................ 403
Uso de elementos ................................................................................................................... 410
Lectura de un elemento ................................................................................................... 411
Escritura de un elemento ................................................................................................. 411
Valores devueltos ............................................................................................................ 413
Operaciones por lotes ...................................................................................................... 414
Contadores atómicos ....................................................................................................... 416
Escrituras condicionales ................................................................................................... 416
Uso de expresiones ......................................................................................................... 421
Elementos que caducan con tiempo de vida ........................................................................ 446
Uso de elementos: Java ................................................................................................... 453
Uso de elementos: .NET .................................................................................................. 474
Uso de consultas .................................................................................................................... 497
Expresiones de condición de clave .................................................................................... 498

Versión de API 2012-08-10


v
Amazon DynamoDB Guía para desarrolladores

Expresiones de filtro para Query ....................................................................................... 500


Limitación del número de elementos del conjunto de resultados ............................................. 501
Paginación de los resultados de la consulta ........................................................................ 501
Recuento de los elementos de los resultados ...................................................................... 502
Unidades de capacidad que Query consume ....................................................................... 503
Consistencia de lectura de Query ...................................................................................... 503
Consulta: Java ................................................................................................................ 503
Consulta: .NET ................................................................................................................ 509
Uso de operaciones de examen ................................................................................................ 516
Expresiones de filtro para Scan ......................................................................................... 516
Limitación del número de elementos del conjunto de resultados ............................................. 517
Paginación de los resultados ............................................................................................ 517
Recuento de los elementos de los resultados ...................................................................... 518
Unidades de capacidad que Scan consume ........................................................................ 519
Consistencia de lectura de Scan ....................................................................................... 519
Examen en paralelo ........................................................................................................ 520
Examen: Java ................................................................................................................. 522
Examen: .NET ................................................................................................................ 529
Trabajar con el lenguaje de consulta PartiQL .............................................................................. 537
¿Qué es PartiQL? ........................................................................................................... 538
PartiQL en Amazon DynamoDB ........................................................................................ 538
Introducción .................................................................................................................... 538
Tipos de datos ................................................................................................................ 544
Instrucciones .................................................................................................................. 546
Funciones ...................................................................................................................... 553
Operadores .................................................................................................................... 557
Transacciones ................................................................................................................ 558
Operaciones por lotes ...................................................................................................... 561
Políticas de IAM .............................................................................................................. 564
Uso de índices ....................................................................................................................... 567
Índices secundarios globales ............................................................................................ 570
Índices secundarios locales .............................................................................................. 612
Uso de secuencias .................................................................................................................. 650
Opciones ....................................................................................................................... 651
Trabajo con Kinesis Data Streams ..................................................................................... 652
Uso de DynamoDB Streams ............................................................................................. 661
Trabajo con transacciones ........................................................................................................ 689
Cómo funciona ............................................................................................................... 690
Uso de IAM con transacciones .......................................................................................... 696
Código de ejemplo .......................................................................................................... 698
Trabajo con backups ............................................................................................................... 701
Backup y restauración bajo demanda ................................................................................. 701
Recuperación a un momento dado .................................................................................... 715
Acceleration en memoria con DAX .................................................................................................... 722
Casos de uso de DAX ............................................................................................................. 723
Notas de uso de DAX .............................................................................................................. 723
Cómo funciona ....................................................................................................................... 724
Cómo procesa DAX las solicitudes .................................................................................... 725
Caché de elementos ........................................................................................................ 727
Caché de consultas ......................................................................................................... 727
Componentes de los clústeres .................................................................................................. 728
Nodos ............................................................................................................................ 728
Clústeres ....................................................................................................................... 728
Regiones y zonas de disponibilidad ................................................................................... 729
Grupos de parámetros ..................................................................................................... 730
Grupos de seguridad ....................................................................................................... 730
ARN del clúster .............................................................................................................. 730

Versión de API 2012-08-10


vi
Amazon DynamoDB Guía para desarrolladores

Punto de enlace de clúster ............................................................................................... 730


Puntos de enlace de nodos .............................................................................................. 731
Grupos de subredes ........................................................................................................ 731
Eventos ......................................................................................................................... 731
Maintenance Window (Período de mantenimiento) ............................................................... 731
Creación de Cluster de DAX ..................................................................................................... 732
Creación de un rol de servicio de IAM para que DAX obtenga acceso a DynamoDB ................... 732
Mediante AWS CLI .......................................................................................................... 734
Mediante la consola ........................................................................................................ 738
Modelo de consistencia ............................................................................................................ 741
Consistencia entre los nodos de los clúst ........................................................................... 741
Comportamiento de la caché de elementos de .................................................................... 741
Comportamiento de la caché de consultas de ...................................................................... 744
Lecturas transaccionales y de consistencia alta ................................................................... 744
Almacenamiento en caché negativo ................................................................................... 745
Estrategias de escritura .................................................................................................... 745
Desarrollo con el cliente de DAX ............................................................................................... 747
Tutorial: Ejecución de un ejemplo de aplicación ................................................................... 748
Modificación de una aplicación existente para que use DAX .................................................. 785
Consulta de índices secundarios globales ........................................................................... 788
Administración de clústeres de DAX .......................................................................................... 791
Permisos de IAM para administrar clústeres de DAX ............................................................ 791
Escalado de un clúster de DAX ......................................................................................... 793
Personalización de los ajustes de los clústeres .................................................................... 794
Configuración de los ajustes de TTL .................................................................................. 795
Compatibilidad con el etiquetado en DAX ........................................................................... 796
Integración de AWS CloudTrail ......................................................................................... 797
Supresión de clústeres de DAX ......................................................................................... 797
Monitorización de DAX ............................................................................................................. 797
Herramientas de monitorización ......................................................................................... 798
Monitoreo con CloudWatch ............................................................................................... 799
Registro de operaciones de DAX con DAXAWS CloudTrail .................................................... 813
Instancias de ráfagas DAX T3/T2 .............................................................................................. 813
Familia de instancias DAX T2 ........................................................................................... 813
Familia de instancias de DAX T3 ....................................................................................... 814
Control de acceso DAX ............................................................................................................ 814
Rol de servicio de IAM para DAX ...................................................................................... 815
Política de IAM para permitir el acceso a un clúster de DAX .................................................. 816
Caso práctico: Acceso a DynamoDB y DAX ........................................................................ 817
Acceso a DynamoDB, pero sin acceso con DAX .................................................................. 818
Acceso a DynamoDB y DAX ............................................................................................. 819
Acceso a DynamoDB a través de DAX, pero sin acceso directo a DynamoDB ........................... 823
Cifrado DAX en reposo ............................................................................................................ 825
Habilitación del cifrado en reposo mediante la AWS Management Console ............................... 826
Cifrado de DAX en tránsito ....................................................................................................... 826
Uso de roles vinculados a servicios para DAX ............................................................................. 827
Permisos de roles vinculados a servicios para DAX .............................................................. 827
Creación de un rol vinculado a un servicio para DAX ............................................................ 828
Edición de un rol vinculado a un servicio para DAX .............................................................. 829
Eliminación de un rol vinculado a un servicio para DAX ........................................................ 829
Acceso a DAX a través deAWSCuentas ..................................................................................... 830
Configurar IAM ............................................................................................................... 830
Configurar una VPC ........................................................................................................ 832
Modificar el cliente de DAX para permitir el acceso de entre cuentas ....................................... 834
Guía de tamaño de clúster de DAX ........................................................................................... 837
Overview ........................................................................................................................ 837
Estimación del tráfico ....................................................................................................... 837

Versión de API 2012-08-10


vii
Amazon DynamoDB Guía para desarrolladores

Prueba de carga ............................................................................................................. 838


Referencia de la API ............................................................................................................... 839
NoSQL Workbench .......................................................................................................................... 840
Descargar .............................................................................................................................. 840
Modelador de datos ................................................................................................................. 841
Creación de un nuevo modelo .......................................................................................... 841
Importación de un modelo existente ................................................................................... 848
Exportación de un modelo ................................................................................................ 851
Edición de un modelo existente ......................................................................................... 853
Visualizador de datos .............................................................................................................. 855
Incorporación de datos de muestra .................................................................................... 856
Facetas ......................................................................................................................... 857
Vista agregada ............................................................................................................... 858
Confirmación de un modelo de datos ................................................................................. 859
Generador de operaciones ....................................................................................................... 864
Exploración de conjuntos de datos .................................................................................... 864
Generación de operaciones .............................................................................................. 868
Modelos de datos de ejemplo ................................................................................................... 879
Modelo de datos de empleados ........................................................................................ 880
Modelo de datos del foro de debate ................................................................................. 880
Modelo de datos de biblioteca de música ........................................................................... 880
Modelo de datos de estación de esquí ............................................................................... 881
Modelo de datos de ofertas de tarjetas de crédito ................................................................ 881
Modelo de datos de marcadores ....................................................................................... 881
Historial de versiones .............................................................................................................. 882
Seguridad ...................................................................................................................................... 883
Protección de los datos ............................................................................................................ 883
Cifrado en reposo ........................................................................................................... 884
Protección de datos en DAX ............................................................................................. 893
Privacidad del tráfico entre redes ...................................................................................... 893
Identity and Access Management .............................................................................................. 893
Identity and Access Management ...................................................................................... 894
Identity and Access Management os en DAX ...................................................................... 925
Validación de la conformidad .................................................................................................... 925
Resiliencia .............................................................................................................................. 926
Seguridad de la infraestructura .................................................................................................. 926
Uso de puntos de enlace de la VPC .................................................................................. 927
Configuración y análisis de vulnerabilidades ................................................................................ 933
Prácticas recomendadas de seguridad ....................................................................................... 933
Prácticas recomendadas preventivas de seguridad de .......................................................... 934
Prácticas recomendadas de detección de seguridad ............................................................. 935
Monitorización ................................................................................................................................. 938
Registro y monitorización en DynamoDB .................................................................................... 938
Herramientas de monitorización ......................................................................................... 939
Monitorización con Amazon CloudWatch ............................................................................ 940
Registro de operaciones de DynamoDB utilizandoAWS CloudTrail .......................................... 964
Registro y monitorización en DAX ............................................................................................. 980
Contributor Insights ................................................................................................................. 980
Cómo funciona ............................................................................................................... 981
Introducción .................................................................................................................... 985
Uso de IAM .................................................................................................................... 989
Prácticas recomendadas de .............................................................................................................. 993
Diseño NoSQL ........................................................................................................................ 994
NoSQL frente a .............................................................................................................. 994
Dos conceptos clave ....................................................................................................... 995
Enfoque general .............................................................................................................. 995
Diseño de claves de partición ................................................................................................... 996

Versión de API 2012-08-10


viii
Amazon DynamoDB Guía para desarrolladores

Capacidad de ráfagas ...................................................................................................... 996


Capacidad de adaptación ................................................................................................. 997
Distribución de cargas de trabajo ...................................................................................... 998
Fragmentación de escritura .............................................................................................. 999
Carga eficiente de datos ................................................................................................. 1000
Diseño de clave de ordenación ............................................................................................... 1001
Control de la versión ...................................................................................................... 1002
Índices secundarios ............................................................................................................... 1003
Directrices generales ...................................................................................................... 1003
Índices dispersos ........................................................................................................... 1005
Agregación ................................................................................................................... 1007
Sobrecarga de GSI ........................................................................................................ 1007
Sagmentación de GSI .................................................................................................... 1008
Creación de una réplica ................................................................................................. 1009
Elementos grandes ................................................................................................................ 1010
Compresión .................................................................................................................. 1010
Uso de Amazon S3 ....................................................................................................... 1011
Datos de series temporales .................................................................................................... 1011
Patrón de diseño de los datos de series temporales ........................................................... 1011
Ejemplos de tablas de series temporales .......................................................................... 1012
Relaciones de varios a varios ................................................................................................. 1012
Listas de adyacencia ..................................................................................................... 1012
Gráficos materializados .................................................................................................. 1014
DynamoDB híbrida: RDBMS ................................................................................................... 1017
Sin migrar .................................................................................................................... 1017
Implementación de un sistema híbrido .............................................................................. 1017
Modelos relacionales .............................................................................................................. 1018
Primeros pasos ............................................................................................................. 1021
Ejemplo ........................................................................................................................ 1022
Consulta y examen ................................................................................................................ 1024
Rendimiento de examen ................................................................................................. 1024
Evite los picos .............................................................................................................. 1024
Examen en paralelo ....................................................................................................... 1027
Integración con otrosAWSServicios .................................................................................................. 1029
Integración con Amazon Cognito ............................................................................................. 1029
Integración con Amazon Redshift ............................................................................................. 1031
Integración con Amazon EMR ................................................................................................. 1032
Overview ...................................................................................................................... 1032
Tutorial: Uso de Amazon DynamoDB y Apache Hive ........................................................... 1033
Crear una tabla externa en Hive ...................................................................................... 1039
Procesamiento de instrucciones de HiveQL ....................................................................... 1041
Consulta de datos en DynamoDB .................................................................................... 1042
Copia de datos en y desde Amazon DynamoDB ................................................................ 1044
Ajuste del desempeño .................................................................................................... 1053
Export to Amazon S3 ............................................................................................................. 1057
Cómo funciona .............................................................................................................. 1058
Solicitud de una exportación ........................................................................................... 1058
Export output ................................................................................................................ 1062
Uso de las exportaciones con otros servicios ..................................................................... 1065
Cuotas ......................................................................................................................................... 1066
Modo de capacidad de lectura/escritura y rendimiento ................................................................. 1066
Tamaños de las unidades de capacidad (para las tablas aprovisionadas) ............................... 1066
Tamaños de las unidades de solicitud (para las tablas bajo demanda) ................................... 1067
Cuotas de rendimiento predeterminadas ........................................................................... 1067
Aumento o reducción del rendimiento (en las tablas aprovisionadas) ..................................... 1068
Tables ................................................................................................................................. 1068
Tamaño de la tabla ....................................................................................................... 1068

Versión de API 2012-08-10


ix
Amazon DynamoDB Guía para desarrolladores

Tablas por cuenta ......................................................................................................... 1069


Tablas globales ..................................................................................................................... 1069
Índices secundarios ............................................................................................................... 1069
Índices secundarios por tabla .......................................................................................... 1069
Atributos de índice secundario proyectados por tabla .......................................................... 1069
Claves de partición y claves de ordenación ............................................................................... 1070
Longitud de la clave de partición ..................................................................................... 1070
Valores de clave de partición .......................................................................................... 1070
Longitud de la clave de ordenación .................................................................................. 1070
Valores de clave de ordenación ....................................................................................... 1070
Reglas de nomenclatura ......................................................................................................... 1070
Nombres de tabla y nombres de índice secundarios ........................................................... 1070
Nombres de los atributos ................................................................................................ 1070
Tipos de datos ...................................................................................................................... 1071
String ........................................................................................................................... 1071
Number ........................................................................................................................ 1071
Binary .......................................................................................................................... 1071
Items ................................................................................................................................... 1071
Tamaño de elemento ..................................................................................................... 1071
Tamaño del elemento para tablas con índices secundarios locales ........................................ 1072
Attributes .............................................................................................................................. 1072
Pares de nombre-valor de los atributos por elemento .......................................................... 1072
Número de valores de una lista, un mapa o un conjunto ...................................................... 1072
Valores de los atributos .................................................................................................. 1072
Profundidad de los atributos anidados .............................................................................. 1072
Parámetros de expresión ........................................................................................................ 1072
Lengths ........................................................................................................................ 1072
Operadores y operandos ................................................................................................ 1073
Palabras reservadas ...................................................................................................... 1073
Transacciones DynamoDB ...................................................................................................... 1073
DynamoDB Streams .............................................................................................................. 1073
Lectores simultáneos de un fragmento en DynamoDB Streams ............................................. 1073
Capacidad de escritura máxima de una tabla con un flujo habilitado ...................................... 1074
DynamoDB Accelerator (DAX) ................................................................................................. 1074
Disponibilidad por región de AWS .................................................................................... 1074
Nodes .......................................................................................................................... 1074
Grupos de parámetros ................................................................................................... 1074
Grupos de subredes ...................................................................................................... 1074
Límites específicos de API ...................................................................................................... 1075
DynamoDB ado en reposo ...................................................................................................... 1076
Exportación de tablas a Amazon S3 ......................................................................................... 1076
Referencia de la API ...................................................................................................................... 1077
Apéndice ...................................................................................................................................... 1078
Solución de problemas de establecimiento de conexiones SSL/TLS de .......................................... 1078
Probar su aplicación o servicio ........................................................................................ 1078
Probar el navegador del cliente ....................................................................................... 1079
Actualización del cliente de aplicación de software ............................................................. 1079
Actualizar el navegador del cliente ................................................................................... 1079
Actualización manual del paquete de certificados ............................................................... 1079
Ejemplos de tablas y datos ..................................................................................................... 1080
Ejemplos de archivos de datos ........................................................................................ 1081
Creación de ejemplos de tablas y carga de datos ....................................................................... 1089
Creación de ejemplos de tablas y carga de datos: Java ...................................................... 1090
Creación de ejemplos de tablas y carga de datos: .NET ...................................................... 1097
Aplicación de ejemplo de conAWS SDK for Python (Boto3) .......................................................... 1105
Paso 1: Implementación y pruebas localmente ................................................................... 1106
Paso 2: Examinar el modelo de datos y los detalles de implementación .................................. 1110

Versión de API 2012-08-10


x
Amazon DynamoDB Guía para desarrolladores

Paso 3: Implementación en producción ............................................................................. 1117


Paso 4: Eliminación de los recursos ................................................................................. 1124
Integración con AWS Data Pipeline .......................................................................................... 1125
Requisitos previos para exportar e importar datos .............................................................. 1127
Exportación de datos de DynamoDB a Amazon S3 ............................................................ 1132
Importación de datos de Amazon S3 a DynamoDB ............................................................. 1133
Troubleshooting ............................................................................................................. 1134
Plantillas predefinidas paraAWS Data Pipeliney DynamoDB ................................................. 1135
Amazon DynamoDB Storage Backend for Titan ......................................................................... 1135
Palabras reservadas en DynamoDB ......................................................................................... 1135
Parámetros condicionales heredados ........................................................................................ 1144
AttributesToGet ............................................................................................................. 1145
AttributeUpdates ............................................................................................................ 1146
ConditionalOperator ....................................................................................................... 1148
Expected ...................................................................................................................... 1148
KeyConditions ............................................................................................................... 1151
QueryFilter .................................................................................................................... 1153
ScanFilter ..................................................................................................................... 1155
Escritura de condiciones con parámetros heredados ........................................................... 1156
Versión anterior del API de bajo nivel (2011-12-05) .................................................................... 1161
BatchGetItem ................................................................................................................ 1162
BatchWriteItem .............................................................................................................. 1167
CreateTable .................................................................................................................. 1172
DeleteItem .................................................................................................................... 1177
DeleteTable .................................................................................................................. 1181
DescribeTables ............................................................................................................. 1184
GetItem ........................................................................................................................ 1187
ListTables ..................................................................................................................... 1189
PutItem ........................................................................................................................ 1192
Query .......................................................................................................................... 1197
Scan ............................................................................................................................ 1206
UpdateItem ................................................................................................................... 1218
UpdateTable ................................................................................................................. 1224
Historial de revisión ....................................................................................................................... 1228
Actualizaciones anteriores ....................................................................................................... 1232
.................................................................................................................................................. mcclv

Versión de API 2012-08-10


xi
Amazon DynamoDB Guía para desarrolladores
Alta disponibilidad y durabilidad

¿Qué es Amazon DynamoDB?


Bienvenido a la Guía para desarrolladores de Amazon DynamoDB.

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

Alta disponibilidad y durabilidad


DynamoDB distribuye automáticamente los datos y el tráfico de las tablas entre un número suficiente
de servidores para satisfacer sus requisitos de almacenamiento y desempeño, al mismo tiempo que
mantiene un desempeño uniforme y rápido. Todos los datos se almacenan en discos de estado sólido
(SSD) y se replican automáticamente en varias zonas de disponibilidad de unAWSRegión, proporcionando
alta disponibilidad incorporada y durabilidad de los datos. Puede utilizar tablas globales para mantener
sincronizadas las tablas de DynamoDB enAWSRegiones de. Para obtener más información, consulte
Tablas globales: Replicación en varias regiones con DynamoDB (p. 370).

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.

Versión de API 2012-08-10


1
Amazon DynamoDB Guía para desarrolladores
Cómo funciona

Para comenzar rápidamente a trabajar con DynamoDB, consulteIntroducción a DynamoDB yAWSSDK


de (p. 82).

Para obtener más información sobre el desarrollo de aplicaciones, consulte los enlaces siguientes:

• Programación con DynamoDB y elAWSSDK de (p. 214)


• Uso de tablas, elementos, consultas, análisis e índices (p. 344)

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.

Amazon DynamoDB: Cómo funciona


En las secciones siguientes se incluye información general sobre los componentes del servicio de Amazon
DynamoDB y las interacciones entre ellos.

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)

Componentes básicos de Amazon DynamoDB


En DynamoDB se trabaja principalmente con tablas, elementos y atributos. Atablaes una colección
deITEMS, y cada elemento es una colección deatributos. DynamoDB utiliza claves principales para
identificar de forma exclusiva cada uno de los elementos de la tabla e índices secundarios para
proporcionar mayor flexibilidad a la hora de realizar consultas. Puede utilizar las DynamoDB Streams para
capturar los eventos de modificación de datos en las tablas de DynamoDB.

Versión de API 2012-08-10


2
Amazon DynamoDB Guía para desarrolladores
Componentes básicos

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)

Tablas, elementos y atributos


A continuación, se indican los componentes básicos de DynamoDB:

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

Versión de API 2012-08-10


3
Amazon DynamoDB Guía para desarrolladores
Componentes básicos

Tenga en cuenta lo siguiente en relación con la tabla People:

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

Versión de API 2012-08-10


4
Amazon DynamoDB Guía para desarrolladores
Componentes básicos

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

Tenga en cuenta lo siguiente en relación con la tabla Music:

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

Versión de API 2012-08-10


5
Amazon DynamoDB Guía para desarrolladores
Componentes básicos

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

DynamoDB admite dos tipos distintos de clave principal:

• 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

La clave de partición de un elemento también se denomina atributo hash. El términoatributo


hashse deriva del uso de una función hash interna en DynamoDB que distribuye los elementos de
datos de manera uniforme entre las particiones, según sus valores de clave de partición.
Versión de API 2012-08-10
6
Amazon DynamoDB Guía para desarrolladores
Componentes básicos

La clave de ordenación de un elemento también se denomina atributo de rango. El términoatributo


rangese deriva de la forma en que DynamoDB almacena en ubicaciones físicamente contiguas
todos los elementos que tienen la misma clave de partición, ordenados según el valor de la clave
de ordenación.

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.

DynamoDB admite dos tipos de índices:

• Í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.

Versión de API 2012-08-10


7
Amazon DynamoDB Guía para desarrolladores
Componentes básicos

Tenga en cuenta lo siguiente en relación con el índice GenreAlbumTitle:

• 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

Versión de API 2012-08-10


8
Amazon DynamoDB Guía para desarrolladores
Componentes básicos

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.

Versión de API 2012-08-10


9
Amazon DynamoDB Guía para desarrolladores
API de DynamoDB

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.

Versión de API 2012-08-10


10
Amazon DynamoDB Guía para desarrolladores
API de DynamoDB

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

PartiQL - Un lenguaje de consulta compatible con SQL


• ExecuteStatement: lee varios elementos de una tabla. También puede escribir o actualizar un solo
elemento de una tabla. Al escribir o actualizar un único elemento, debe especificar los atributos de clave
principal.
• BatchExecuteStatement: escribe, actualiza o lee varios elementos de una tabla. Esto es más
eficiente queExecuteStatementPorque la aplicación solo tiene que completar un único recorrido de
ida y vuelta para escribir o leer todos los elementos.

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

Versión de API 2012-08-10


11
Amazon DynamoDB Guía para desarrolladores
API de DynamoDB

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.

PartiQL - Un lenguaje de consulta compatible con SQL


• ExecuteTransaction: operación por lotes que permite realizar operaciones CRUD en varios
elementos, tanto en el seno de tablas como entre ellas, con un resultado garantizado de «todo o nada».

Versión de API 2012-08-10


12
Amazon DynamoDB Guía para desarrolladores
Reglas de nomenclatura y tipos de datos

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.

Reglas de nomenclatura y tipos de datos


En esta sección se describen las reglas de nomenclatura de Amazon DynamoDB y los distintos tipos
de datos que admite DynamoDB. Existen límites que se aplican a los tipos de datos. Para obtener más
información, consulte Tipos de datos (p. 1071).

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.

A continuación, se indican las reglas de nomenclatura de DynamoDB:

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

Palabras reservadas y caracteres especiales


DynamoDB tiene una lista de palabras reservadas y caracteres especiales. Para obtener una lista
completa de palabras reservadas de DynamoDB, consulte.Palabras reservadas en DynamoDB (p. 1135).
Además, los siguientes caracteres tienen un significado especial en DynamoDB:#(hash) y:(dos puntos).

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

Versión de API 2012-08-10


13
Amazon DynamoDB Guía para desarrolladores
Reglas de nomenclatura y tipos de datos

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.

• Rango de valores positivos: 1E-130 a


9.9999999999999999999999999999999999999999999999999999999999999999999999999999
• Rango de valores negativos:
-9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999

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.

Versión de API 2012-08-10


14
Amazon DynamoDB Guía para desarrolladores
Reglas de nomenclatura y tipos de datos

Para obtener más información, consulte http://en.wikipedia.org/wiki/Unix_time.

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

Para obtener más información, consulte http://en.wikipedia.org/wiki/ISO_8601.

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

Un atributo de tipo Boolean puede almacenar los valores true o false.

Versión de API 2012-08-10


15
Amazon DynamoDB Guía para desarrolladores
Reglas de nomenclatura y tipos de datos

Null

Null representa un atributo con un estado desconocido o sin definir.

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.

FavoriteThings: ["Cookies", "Coffee", 3.14159]

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},

Versión de API 2012-08-10


16
Amazon DynamoDB Guía para desarrolladores
Consistencia de lectura

Pencils: { Quantity : 2},


Erasers: { Quantity : 1}
}
]
}

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.

En el siguiente ejemplo se muestra un conjunto de cadenas, un conjunto de números y un conjunto de


valores binarios:

["Black", "Green", "Red"]

[42.2, -19, 7.5, 3.14]

["U3Vubnk=", "UmFpbnk=", "U25vd3k="]

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.

: DynamoDB admiteconsistencia finalyFuertemente coherenteLee.

Lecturas consistentes finales

Versión de API 2012-08-10


17
Amazon DynamoDB Guía para desarrolladores
Modo de capacidad de lectura/escritura

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.

Lecturas de consistencia alta

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.

Modo de capacidad de lectura/escritura


Amazon DynamoDB dispone de dos modos de capacidad de lectura/escritura para procesar las lecturas y
escrituras en las tablas:

• Bajo demanda
• Capacidad aprovisionada (valor predeterminado, apta para capa gratuita)

El modo de capacidad de lectura/escritura controla cómo se le cobrará el rendimiento de lectura y escritura


y cómo se administra la capacidad. Puede establecer el modo de capacidad de lectura/escritura al crear
una tabla y también modificarlo más adelante.

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)

Modo bajo demanda


Amazon DynamoDB bajo demanda es una opción de facturación flexible que permite atender a miles de
solicitudes por segundo sin tener que planificar la capacidad. DynamoDB bajo demanda ofrece precios de
pago por solicitud para las solicitudes de lectura y escritura. De este modo, únicamente tendrá que pagar
por aquello que utilice.

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

Versión de API 2012-08-10


18
Amazon DynamoDB Guía para desarrolladores
Modo de capacidad de lectura/escritura

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:

• Crea nuevas tablas con cargas de trabajo desconocidas.


• El tráfico de la aplicación es impredecible.
• Prefiere disfrutar de la comodidad de pagar solo por lo que usa.

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)

Unidades de solicitud de lectura y de escritura


Para las tablas con el modo bajo demanda, no es preciso especificar el rendimiento de lectura y escritura
que espera de su aplicación. DynamoDB le carga las lecturas y escrituras que la aplicación lleva a cabo en
las tablas en términos de unidades de solicitud de lectura y de escritura, respectivamente.

•  Oneunidad de solicitud de lecturarepresenta una solicitud de lectura de consistencia alta, o dos


solicitudes de lectura consistente final, para un elemento con un tamaño de hasta 4 KB. Dos unidades
de solicitud de lectura representan una lectura transaccional respecto a los elementos de hasta 4 KB.
Si necesita leer un elemento mayor que 4 KB, DynamoDB necesita unidades de solicitud de lectura
adicionales. El número total de unidades de solicitud 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 solicitud de lectura para sostener una
lectura de consistencia alta, 1 unidad de solicitud de lectura si opta por las lecturas consistentes finales o
4 unidades de solicitud de lectura para una solicitud de lectura transaccional.
Note

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

Versión de API 2012-08-10


19
Amazon DynamoDB Guía para desarrolladores
Modo de capacidad de lectura/escritura

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.

Picos de tráfico y propiedades de escalado


Las tablas de DynamoDB que utilizan el modo de capacidad bajo demanda se adaptan automáticamente
al volumen de tráfico de la aplicación. El modo de capacidad bajo demanda acomoda al instante hasta el
doble del tráfico máximo alcanzado previamente en una tabla. 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 anterior ha
sido de 50 000 lecturas, el modo de capacidad bajo demanda acomoda al instante un tráfico sostenido de
hasta 100 000 lecturas por segundo. Si la aplicación sostiene un tráfico de 100 000 lecturas por segundo,
ese máximo se convierte en el nuevo pico anterior, lo que permite que el tráfico subsiguiente alcance hasta
200 000 lecturas por segundo.

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.

Rendimiento inicial del modo de capacidad bajo demanda


Si recientemente ha cambiado una tabla al modo de capacidad bajo demanda por primera vez, o si ha
creado una tabla con este modo habilitado, la tabla presentará la configuración de tráfico máximo anterior,
aunque no haya atendido ningún tráfico en este modo:

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

Comportamiento de las tablas al cambiar el modo de capacidad de lectura/


escritura
Cuando se cambia una tabla del modo de capacidad aprovisionada al modo de capacidad bajo demanda,
DynamoDB efectúa varios cambios en la estructura y las particiones de la tabla. Este proceso puede tardar
varios minutos. Durante el periodo de cambio, la tabla proporciona el rendimiento acorde con las unidades
de capacidad de lectura y de escritura aprovisionadas previamente. Al cambiar del modo de capacidad
bajo demanda al modo de capacidad aprovisionada, la tabla proporciona el rendimiento acorde con el
tráfico máximo alcanzado anteriormente mientras la tabla estaba en el 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

Versión de API 2012-08-10


20
Amazon DynamoDB Guía para desarrolladores
Modo de capacidad de lectura/escritura

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.

El modo aprovisionado es una opción interesante si se da cualquiera de las condiciones siguientes:

• El tráfico de la aplicación es predecible.


• Ejecuta aplicaciones cuyo tráfico es constante o aumenta gradualmente.
• Puede prever los requisitos de capacidad para controlar los costos.

Unidades de capacidad de lectura y de escritura


Para las tablas en modo aprovisionado, la capacidad de rendimiento se especifica en términos de
unidades de capacidad de lectura (RCU) y de escritura (WCU):

•  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:

• Realizar lecturas de consistencia alta de hasta 24 KB por segundo (4 KB × 6 unidades de capacidad de


lectura).
• Realizar lecturas consistentes finales de hasta 48 KB por segundo (el doble de rendimiento de lectura).
• Realizar solicitudes de lectura transaccionales de hasta 12 KB por segundo.

Versión de API 2012-08-10


21
Amazon DynamoDB Guía para desarrolladores
Modo de capacidad de lectura/escritura

• Escribir hasta 6 KB por segundo (1 KB × 6 unidades de capacidad de escritura).


• Realizar solicitudes de escritura transaccionales de hasta 3 KB por segundo.

Para obtener más información, consulte Administración de la configuración en tablas de capacidad


provisionadas de DynamoDB (p. 350).

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.

Auto Scaling de DynamoDB


El escalado automático de DynamoDB administra activamente la capacidad de rendimiento de las tablas
e índices secundarios globales de. Con Auto Scaling, se define un rango (los límites superior e inferior) de
unidades de capacidad de lectura y escritura. También se definir un porcentaje de objetivo de utilización
comprendido en ese rango. El escalado automático de DynamoDB intenta mantener el objetivo de
utilización aunque la carga de trabajo de la aplicación aumente o disminuya.

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

En el modo de capacidad bajo demanda no está disponible la capacidad reservada.

Versión de API 2012-08-10


22
Amazon DynamoDB Guía para desarrolladores
Partitions y distribución de datos

Para administrar la capacidad reservada, vaya a la secciónConsola DynamoDBy elijaCapacidad reservada.


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

Partitions y distribución de datos


Amazon DynamoDB almacena los datos en las particiones. Apartitiones una asignación de
almacenamiento a una tabla que se sustenta en discos de estado sólido (SSD) y se replica
automáticamente en varias zonas de disponibilidad de unAWSRegión . DynamoDB se encarga de todo lo
que respecta a la administración de las particiones para que usted no tenga que ocuparse de ello.

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.

DynamoDB asigna particiones adicionales a una tabla en las siguientes situaciones:

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

Distribución de datos: Clave de partición


Si la tabla tiene una clave principal simple (solo clave de partición), DynamoDB almacenará y recuperará
cada elemento basándose en su valor de clave de partición.

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.

Versión de API 2012-08-10


23
Amazon DynamoDB Guía para desarrolladores
Partitions y distribución de datos

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.

Distribución de datos: Clave de partición y clave de ordenación


Si la tabla tiene una clave principal compuesta (clave de partición y clave de ordenación), DynamoDB
calcula el valor hash de la clave de partición de la misma forma que se describe enDistribución de datos:
Clave de partición (p. 23). No obstante, almacena todos los elementos con el mismo valor de clave de
participación físicamente juntos, ordenados por valor de clave de ordenación.

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.

Versión de API 2012-08-10


24
Amazon DynamoDB Guía para desarrolladores
Partitions y distribución de datos

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.

Versión de API 2012-08-10


25
Amazon DynamoDB Guía para desarrolladores
De SQL a NoSQL

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)

¿Base de datos relacional (SQL) o NoSQL?


Los requisitos de las aplicaciones actuales son más exigentes que nunca. Por ejemplo, un juego online
podría comenzar con unos pocos usuarios y una pequeña cantidad de datos. No obstante, si el juego
tiene éxito, puede superar fácilmente los recursos del sistema de administración de bases de datos
subyacente. Es frecuente que las aplicaciones basadas en Web tengan cientos, miles o millones de
usuarios simultáneos, que generen nuevos datos del orden de terabytes o más. Las bases de datos
de este tipo de aplicaciones deben administrar decenas o cientos de miles de lecturas y escrituras por
segundo.

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.

Versión de API 2012-08-10


26
Amazon DynamoDB Guía para desarrolladores
¿Base de datos relacional o NoSQL?

Característica Sistema de bases de datos Amazon DynamoDB


relacionales (RDBMS)

Cargas de trabajo óptimas Consultas ad-hoc; Aplicaciones a escala Web,


almacenamiento de datos; OLAP tales como redes sociales,
(procesamiento analítico online). juegos, intercambio de contenido
multimedia o Internet de las
cosas (IoT).

Modelo de datos El modelo relacional requiere un DynamoDB no utiliza ningún


esquema bien definido, cuyos esquema. Cada tabla debe
datos estén normalizados en tener una clave principal para
tablas, filas y columnas. Además, identificar cada elemento de
se definen todas las relaciones datos de forma exclusiva, pero
entre las tablas, las columnas, no existen restricciones similares
los índices y otros componentes para otros atributos que no son
de las bases de datos. de clave. DynamoDB puede
administrar datos estructurados o
semiestructurados, incluidos los
documentos JSON.

Acceso a los datos SQL es el lenguaje de consulta Puede utilizar la herramienta


estándar para almacenar y deAWS Management Consoleo
recuperar datos. Las bases de elAWS CLIPara trabajar con
datos relacionales ofrecen un DynamoDB y llevar a cabo
amplio conjunto de herramientas tareas ad hoc. Las aplicaciones
que simplifican el desarrollo de pueden utilizar elAWSLos kits
las aplicaciones basadas en de desarrollo de software (SDK,
bases de datos, pero en todas por sus siglas en inglés) para
estas herramientas se utiliza trabajar con DynamoDB a través
SQL. de interfaces basadas en objetos,
centradas en documentos o de
bajo nivel.

Desempeño Las bases de datos relacionales DynamoDB está optimizado


están optimizadas para el para la computación, por lo
almacenamiento, de modo que, que el rendimiento depende
por lo general, su rendimiento principalmente del hardware
depende del subsistema de subyacente y de la latencia
disco. Los desarrolladores de la red. Como servicio
y administradores de bases administrado, DynamoDB
de datos deben optimizar las desvincula al desarrollador y
consultas, los índices y la a sus aplicaciones de estos
estructura de las tablas para detalles de implementación, para
lograr el máximo rendimiento. que pueda centrarse en diseñar y
crear aplicaciones sólidas de alto
desempeño.

Escalado Resulta más fácil de escalar DynamoDB se ha diseñado


con un hardware más rápido. para ser escalable por medio
Además, es posible que las de clústeres de hardware
tablas de la base de datos distribuidos. Este diseño permite
abarquen varios hosts en un obtener un rendimiento mejorado
sistema distribuido, pero para ello sin aumentar la latencia. Los
se requiere una mayor inversión. clientes especificar sus requisitos
Las bases de datos relacionales de rendimiento y DynamoDB
presentan tamaños máximos en asigna recursos suficientes para

Versión de API 2012-08-10


27
Amazon DynamoDB Guía para desarrolladores
Características de las bases de datos

Característica Sistema de bases de datos Amazon DynamoDB


relacionales (RDBMS)
atención al número y al tamaño satisfacer estos requisitos. No
de los archivos, lo que impone hay límite en cuanto al número
límites máximos de escalabilidad. de elementos por tabla, ni al
tamaño total de dicha tabla.

Características de las bases de datos


Antes de que su aplicación pueda acceder a una base de datos, debe autenticarse para garantizar que la
aplicación pueda usar la base de datos. Debe autorizarse para que la aplicación pueda realizar solo las
acciones para las que tiene permisos.

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.

Característica Sistema de bases de datos Amazon DynamoDB


relacionales (RDBMS)

Herramientas para obtener La mayoría de las bases de En la mayoría de los casos,


acceso a la base de datos datos relacionales ofrecen una el desarrollador debe escribir
interfaz de línea de comandos el código de aplicación.
(CLI), que permite especificar También puede utilizar laAWS
instrucciones SQL ad-hoc y Management Consoleo elAWS
ver los resultados de forma Command Line Interface(AWS
inmediata. CLI) para enviar solicitudes

Versión de API 2012-08-10


28
Amazon DynamoDB Guía para desarrolladores
Características de las bases de datos

Característica Sistema de bases de datos Amazon DynamoDB


relacionales (RDBMS)
ad hoc a DynamoDB y ver los
resultados.

Conexión a la base de datos Un programa de aplicación DynamoDB es un servicio web y


establece y mantiene una las interacciones con él no tienen
conexión de red con la base estado. Las aplicaciones no
de datos. Cuando la aplicación tienen que mantener conexiones
finaliza, termina la conexión. de red persistentes. En lugar
de ello, la interacción con
DynamoDB se produce mediante
solicitudes y respuestas HTTP
(S).

Autenticación Una aplicación no puede Cada solicitud de DynamoDB


conectarse a la base de datos debe ir acompañada de una firma
hasta que se ha autenticado. criptográfica, que autentica esa
El RDBMS puede llevar a cabo solicitud concreta. LaAWSLos
la autenticación por sí mismo, SDK proporcionan toda la lógica
o bien delegar esta tarea en el necesaria para crear firmas y
sistema operativo host o en un firmar solicitudes. Para obtener
servicio de directorio. más información, consulteFirma
deAWSSolicitudes API deen
laAWSReferencia general de.

Autorización Las aplicaciones solo pueden En DynamoDB, la autorización se


llevar a cabo aquellas acciones administra medianteAWS Identity
para las cuales tienen permiso. and Access Management(IAM).
Los administradores de bases Puede escribir una política de
de datos o los propietarios de las IAM que conceda permisos
aplicaciones pueden utilizar las para un recurso de DynamoDB
instrucciones GRANT y REVOKE (por ejemplo, una tabla) y, a
de SQL para controlar el acceso continuación, permitir a los
a los objetos de base de datos usuarios y los roles de IAM que
(tales como las tablas), los utilicen esa política. En las tablas
datos (como las filas de una de DynamoDB también presenta
tabla) o la capacidad de emitir control de acceso preciso a los
determinadas instrucciones de elementos de datos individuales
SQL. contenidos en las tablas de
DynamoDB. Para obtener más
información, consulte Identity and
Access Management (p. 894).

Envío de una solicitud La aplicación emite una La aplicación envía solicitudes


instrucción de SQL para todas HTTP (S) a DynamoDB. Las
las operaciones de base de solicitudes contienen el nombre
datos que quiere realizar. Al de la operación de DynamoDB
recibir la instrucción de SQL, el que hay que realizar, junto con
RDBMS comprueba su sintaxis, los parámetros. DynamoDB
crea un plan para realizar la ejecuta la solicitud de forma
operación y, a continuación, inmediata.
ejecuta el plan.

Versión de API 2012-08-10


29
Amazon DynamoDB Guía para desarrolladores
Creación de una tabla

Característica Sistema de bases de datos Amazon DynamoDB


relacionales (RDBMS)

Recepción de una respuesta El RDBMS devuelve los DynamoDB devuelve una


resultados de la instrucción de respuesta HTTP (S) que contiene
SQL. Si se produce un error, el los resultados de la operación. Si
RDBMS devuelve un estado de se produce un error, DynamoDB
error y un mensaje. devuelve un estado de error de
HTTP y uno o varios mensajes.

Creación de una tabla


Las tablas son las estructuras de datos fundamentales tanto en las bases de datos relacionales como en
Amazon DynamoDB. Un sistema de administración de bases de datos relacionales (RDBMS) requiere
que se defina el esquema de la tabla al crearla. En cambio, las tablas de DynamoDB no tienen esquemas;
salvo la clave principal, no hay que definir ningún atributo ni tipo de datos adicionales al crear la tabla.

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.

CREATE TABLE Music (


Artist VARCHAR(20) NOT NULL,
SongTitle VARCHAR(30) NOT NULL,
AlbumTitle VARCHAR(25),
Year INT,
Price FLOAT,
Genre VARCHAR(10),
Tags TEXT,
PRIMARY KEY(Artist, SongTitle)
);

La clave principal de esta tabla consta de Artist y SongTitle.

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.

Muchas implementaciones de SQL permiten definir especificaciones de almacenamiento de la tabla en la


propia instrucción CREATE TABLE. A menos que se indique otra cosa, la tabla se crea con los ajustes de
almacenamiento predeterminados. En un entorno de producción, un administrador de base de datos puede
ayudar a determinar los parámetros de almacenamiento óptimos.

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",

Versión de API 2012-08-10


30
Amazon DynamoDB Guía para desarrolladores
Obtención de información sobre una tabla

KeyType: "HASH", //Partition key


},
{
AttributeName: "SongTitle",
KeyType: "RANGE" //Sort key
}
],
AttributeDefinitions: [
{
AttributeName: "Artist",
AttributeType: "S"
},
{
AttributeName: "SongTitle",
AttributeType: "S"
}
],
ProvisionedThroughput: { // Only specified if using provisioned mode
ReadCapacityUnits: 1,
WriteCapacityUnits: 1
}
}

La clave principal de esta tabla consta de Artist (clave de partición) y SongTitle (clave de ordenación).

Debe proporcionar los siguientes parámetros a CreateTable:

• TableName: nombre de la tabla.


• KeySchema: atributos que se utilizan para la clave principal. Para obtener más información, consulte
Tablas, elementos y atributos (p. 3) y Clave principal (p. 6).
• AttributeDefinitions: tipos de datos de los atributos del esquema de claves.
• ProvisionedThroughput (for provisioned tables): número de lecturas y escrituras por
segundo que se requieren para esta tabla. DynamoDB reserva recursos de almacenamiento y del
sistema suficientes para cumplir en todo momento los requisitos de desempeño. Puede usar la acción
UpdateTable para cambiar estos valores más adelante si fuera preciso. No es necesario especificar
los requisitos de almacenamiento de una tabla, porque DynamoDB administra todas las asignaciones del
almacenamiento.

Note

Para obtener ejemplos de código en los que se utiliza CreateTable, consulte Introducción a
DynamoDB yAWSSDK de (p. 82).

Obtención de información sobre una tabla


Puede comprobar que una tabla se ha creado de acuerdo con sus especificaciones. En una base de datos
relacional, se muestra el esquema completo de la tabla. Las tablas de Amazon DynamoDB no tienen
esquema, de modo que solo se muestran los atributos de clave principal.

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

Versión de API 2012-08-10


31
Amazon DynamoDB Guía para desarrolladores
Obtención de información sobre una tabla

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

La clave principal de esta tabla consta de Artist y SongTitle.

DynamoDB
DynamoDB posee unaDescribeTableacción, que es parecida. El único parámetro es el nombre de la
tabla.

{
TableName : "Music"
}

La respuesta de DescribeTable tiene el siguiente aspecto.

{
"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
}
],

...

Versión de API 2012-08-10


32
Amazon DynamoDB Guía para desarrolladores
Escritura de datos en una tabla

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.

Escritura de datos en una tabla


Las tablas de las bases de datos relacionales contienen filas de datos. Las filas constan de columnas. Las
tablas de Amazon DynamoDB contienenITEMS. Los elementos constan de atributos.

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.

INSERT INTO Music


(Artist, SongTitle, AlbumTitle,
Year, Price, Genre,
Tags)
VALUES(
'No One You Know', 'Call Me Today', 'Somewhat Famous',
2015, 2.14, 'Country',
'{"Composers": ["Smith", "Jones", "Davis"],"LengthInSeconds": 214}'
);

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.

insert into Music value {


'Artist': 'No One You Know',
'SongTitle': 'Call Me Today',

Versión de API 2012-08-10


33
Amazon DynamoDB Guía para desarrolladores
Escritura de datos en una tabla

'AlbumTitle': 'someonewhat famous',


'Year' : true,
'Genre' : 'Acme'
}

La clave principal de esta tabla consta de Artist y SongTitle. Debe especificar los valores de estos
atributos.
Note

Para obtener ejemplos de código de usandoInsertyExecuteStatement, consulte,


consulteSentencias de inserción PartiQL para DynamoDB (p. 552).

API Classic API Classic


En Amazon DynamoDB, se utiliza elPutItemAcción para agregar un elemento a una tabla.

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

A continuación, se muestran algunos otros ejemplos de PutItem.

Versión de API 2012-08-10


34
Amazon DynamoDB Guía para desarrolladores
Escritura de datos en una tabla

{
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

Además dePutItem, DynamoDB admiteBatchWriteItemPara escribir varios elementos al


mismo tiempo.

Versión de API 2012-08-10


35
Amazon DynamoDB Guía para desarrolladores
Lectura de datos de una tabla

Diferencias clave al leer datos de una tabla


Con SQL, se utiliza la instrucción SELECT para recuperar una o varias filas de una tabla. Se utiliza la
cláusula WHERE para determinar qué datos se devuelven.

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)

Lectura de un elemento usando su clave principal


Un patrón de acceso habitual de acceso a las bases de datos consiste en leer un único elemento de una
tabla. Es preciso especificar la clave principal del elemento que se desea.

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.

Versión de API 2012-08-10


36
Amazon DynamoDB Guía para desarrolladores
Lectura de datos de una tabla

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:

SELECT AlbumTitle, Year, Price


FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'

Observe que la clave principal de esta tabla consta de Artist y SongTitle.

DynamoDB
PartiQL
DynamoDB proporciona laExecuteStatementLa acción para recuperar un elemento por su clave
principal mediante la instrucción SELECT.

select AlbumTitle, Year, Price


FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'

Observe que la clave principal de esta tabla consta de Artist y SongTitle.


Note
La instrucción Select PartiQL se puede utilizar también para consultar o escanear una tabla de
DynamoDB

Para obtener ejemplos de código de usandoSelectyExecuteStatement, consulte, consulteSentencias


PartiQL Select para DynamoDB (p. 546).

API Classic API Classic


DynamoDB proporciona laGetItemPara recuperar un elemento por su clave principal.GetItemes
muy eficiente, porque proporciona acceso directo a la ubicación física del elemento. (Para obtener más
información, consulte Partitions y distribución de datos (p. 23).)

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"

Versión de API 2012-08-10


37
Amazon DynamoDB Guía para desarrolladores
Lectura de datos de una tabla

},
"ProjectionExpression": "AlbumTitle, Year, Price"
}

Observe que la clave principal de esta tabla consta de Artist y SongTitle.

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.

El SQL SQLSELECTadmite muchos tipos de consultas y exámenes de tablas. DynamoDB ofrece


una funcionalidad semejante con suQueryyScanLas acciones, que se describen enConsulta de una
tabla (p. 38)yExamen de una tabla (p. 40).

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

Consulta de una tabla


Otro patrón de acceso habitual consiste en leer varios elementos de una tabla, según los criterios de
consulta.

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 a single song, by primary key */

SELECT * FROM Music


WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today';

/* Return all of the songs by an artist */

SELECT * FROM Music


WHERE Artist='No One You Know';

/* Return all of the songs by an artist, matching first part of title */

Versión de API 2012-08-10


38
Amazon DynamoDB Guía para desarrolladores
Lectura de datos de una tabla

SELECT * FROM Music


WHERE Artist='No One You Know' AND SongTitle LIKE 'Call%';

/* 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 */

SELECT * FROM Music


WHERE Artist='No One You Know' AND SongTitle LIKE '%Today%'
AND Price < 1.00;

Observe que la clave principal de esta tabla consta de Artist y SongTitle.

DynamoDB
PartiQL
DynamoDB proporciona laExecuteStatementpara recuperar varios elementos mediante la instrucción
select.

select AlbumTitle, Year, Price


FROM Music
WHERE Artist='No One You Know'

Tenga en cuenta que esta declaración devolverá todos los elementos para el artista especificado.

Para obtener ejemplos de código de usandoSelectyExecuteStatement, consulte, consulteSentencias


PartiQL Select para DynamoDB (p. 546).

API Classic API Classic


Amazon DynamoDBQueryLa acción permite recuperar datos de forma parecida. La acción Query
proporciona un acceso rápido y eficiente a las ubicaciones físicas en las que se almacenan los datos. Para
obtener más información, consulte Partitions y distribución de datos (p. 23).

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.

En DynamoDB, debe usarExpressionAttributeValuescomo marcador de posición en los parámetros


de las expresiones (tales comoKeyConditionExpressionyFilterExpression). Esto es análogo al
uso de las variables de vínculo de las bases de datos relacionales, que se sustituyen en la instrucción
SELECT por los valores reales en tiempo de ejecución.

Observe que la clave principal de esta tabla consta de Artist y SongTitle.

A continuación se muestran algunos DynamoDBQueryEjemplos de la para las .

// Return a single song, by primary key

{
TableName: "Music",
KeyConditionExpression: "Artist = :a and SongTitle = :t",
ExpressionAttributeValues: {
":a": "No One You Know",
":t": "Call Me Today"

Versión de API 2012-08-10


39
Amazon DynamoDB Guía para desarrolladores
Lectura de datos de una tabla

}
}

// Return all of the songs by an artist

{
TableName: "Music",
KeyConditionExpression: "Artist = :a",
ExpressionAttributeValues: {
":a": "No One You Know"
}
}

// Return all of the songs by an artist, matching first part of title

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

Examen de una tabla


En SQL, una instrucción SELECT sin cláusula WHERE devuelve todas las filas de la tabla. En Amazon
DynamoDB, elScanhace lo mismo. En ambos casos, puede recuperar todos los elementos o solo algunos
de ellos.

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

En los siguientes ejemplos se utiliza una instrucción SELECT.

/* Return all of the data in the table */


SELECT * FROM Music;

/* Return all of the values for Artist and Title */

Versión de API 2012-08-10


40
Amazon DynamoDB Guía para desarrolladores
Administración de índices

SELECT Artist, Title FROM Music;

DynamoDB
PartiQL
DynamoDB proporciona laExecuteStatementpara devolver todo el contenido de una tabla mediante la
instrucción select.

select AlbumTitle, Year, Price


FROM Music

Tenga en cuenta que esta declaración devolverá todos los elementos de la tabla Música.

Para obtener ejemplos de código de usandoSelectyExecuteStatement, consulte, consulteSentencias


PartiQL Select para DynamoDB (p. 546).

API Classic API Classic


DynamoDB proporciona unaScanacción que funciona de forma parecida. A continuación se muestran
algunos ejemplos.

// Return all of the data in the table


{
TableName: "Music"
}

// Return all of the values for Artist and Title


{
TableName: "Music",
ProjectionExpression: "Artist, Title"
}

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)

Versión de API 2012-08-10


41
Amazon DynamoDB Guía para desarrolladores
Administración de índices

• Consulta y examen de un índice (p. 43)

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.

En MySQL, puede crear un índice como se indica a continuación.

CREATE INDEX GenreAndPriceIndex


ON Music (genre, price);

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.

DynamoDB admite dos tipos de índices:

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

Puede agregar un índice secundario global a una tabla existente mediante la


herramientaUpdateTableacción y especificarGlobalSecondaryIndexUpdates.

{
TableName: "Music",
AttributeDefinitions:[
{AttributeName: "Genre", AttributeType: "S"},

Versión de API 2012-08-10


42
Amazon DynamoDB Guía para desarrolladores
Administración de índices

{AttributeName: "Price", AttributeType: "N"}


],
GlobalSecondaryIndexUpdates: [
{
Create: {
IndexName: "GenreAndPriceIndex",
KeySchema: [
{AttributeName: "Genre", KeyType: "HASH"}, //Partition key
{AttributeName: "Price", KeyType: "RANGE"}, //Sort key
],
Projection: {
"ProjectionType": "ALL"
},
ProvisionedThroughput: { // Only specified
if using provisioned mode
"ReadCapacityUnits": 1,"WriteCapacityUnits": 1
}
}
}
]
}

Debe proporcionar los siguientes parámetros a UpdateTable:

• TableName: tabla a la que se asociará el índice.


• AttributeDefinitions: tipos de datos de los atributos de esquema de claves del índice.
• GlobalSecondaryIndexUpdates: detalles sobre el índice que se desea crear.
• IndexName: nombre del índice.
• KeySchema: atributos utilizados para la clave principal del índice.
• Projection: atributos de la tabla que se copian en el índice. En este caso, ALL significa que se
copian todos los atributos.
• ProvisionedThroughput (for provisioned tables): número de lecturas y escrituras por
segundo que se requieren para este índice. Este valor es independiente de los ajustes de rendimiento
aprovisionado de la tabla.

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

Consulta y examen de un índice


Compare la realización de consultas y exámenes de un índice mediante la instrucción SELECT de SQL
con laQueryyScanoperaciones en Amazon DynamoDB.

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.

Versión de API 2012-08-10


43
Amazon DynamoDB Guía para desarrolladores
Administración de índices

Un optimizador de consultas es un componente del sistema de administración de bases de datos


relacionales (RDBMS) que se encarga de evaluar los índices disponibles y determinar si se pueden utilizar
para agilizar consultas. Si los índices pueden utilizarse para agilizar una consulta, el RDBMS obtiene
acceso al índice en primer lugar y, a continuación, lo utiliza para localizar los datos en la tabla.

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.

/* All of the rock songs */

SELECT * FROM Music


WHERE Genre = 'Rock';

/* All of the cheap country songs */

SELECT Artist, SongTitle, Price FROM Music


WHERE Genre = 'Country' AND Price < 0.50;

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.

A continuación se muestran algunas consultas sobreGenreAndPriceIndexEn DynamoDB. El esquema de


claves de este índice consta de Genre y Price.

// All of the rock songs

{
TableName: "Music",
IndexName: "GenreAndPriceIndex",
KeyConditionExpression: "Genre = :genre",
ExpressionAttributeValues: {
":genre": "Rock"
},
};

// All of the cheap country songs

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

// Return all of the data in the index

Versión de API 2012-08-10


44
Amazon DynamoDB Guía para desarrolladores
Modificación de los datos de una tabla

{
TableName: "Music",
IndexName: "GenreAndPriceIndex"
}

Modificación de los datos de una tabla


El lenguaje SQL proporciona la propiedad de SQL yUPDATEInstrucción para modificar datos. Amazon
DynamoDB utiliza la herramienta deUpdateItemoperación para llevar a cabo tareas semejantes.

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.

A continuación se muestra un ejemplo.

{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET RecordLabel = :label",
ExpressionAttributeValues: {
":label": "Global Records"
}
}

Debe especificar la propiedadKeydel elemento que se va a modificar y unUpdateExpressionpara


especificar los valores de atributo.UpdateItemse comporta como una operación «upsert»: Si el elemento
está presente en tabla, se actualiza y, si no está presente, se agrega (inserta).

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",

Versión de API 2012-08-10


45
Amazon DynamoDB Guía para desarrolladores
Eliminación de datos de una tabla

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

Eliminación de datos de una tabla


En SQL, elDELETEinstrucción elimina una o varias filas de una tabla. Amazon DynamoDB utiliza la
herramienta deDeleteItemoperación para eliminar los elementos de uno en uno.

Versión de API 2012-08-10


46
Amazon DynamoDB Guía para desarrolladores
Eliminación de datos de una tabla

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.

DELETE FROM Music


WHERE Artist = 'The Acme Band' AND SongTitle = 'Look Out, World';

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.

DELETE FROM Music WHERE Artist = 'The Acme Band'

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

Además deDeleteItem, Amazon DynamoDB admite unBatchWriteItemPara eliminar varios


elementos a la vez.

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

Versión de API 2012-08-10


47
Amazon DynamoDB Guía para desarrolladores
Eliminación de una tabla

Eliminación de una tabla


En SQL, se utiliza la instrucción DROP TABLE para eliminar una tabla. En Amazon DynamoDB, se utiliza
elDeleteTable.

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.

DROP TABLE Music;

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

Recursos adicionales de Amazon DynamoDB


Temas
• Entradas de blog, repositorios y guías (p. 48)
• Creación de modelos de datos y patrones de diseño (p. 49)
• Advanced Design Patterns con la participación de Rick Houlihan (p. 49)
• Cursos de formación técnica (p. 49)
• Herramientas de programación y visualización (p. 49)

Entradas de blog, repositorios y guías


• Cómo cambiar de RDBMS a DynamoDB en 20 sencillos pasos— Una lista irreverente deJeremy Dalyde
pasos útiles para aprender el modelado de datos.
• Hoja de trucos DynamoDB JavaScript DocumentClient— Una hoja de trucos para ayudarle a empezar a
crear aplicaciones con DynamoDB en un entorno Node.js o JavaScript.

Versión de API 2012-08-10


48
Amazon DynamoDB Guía para desarrolladores
Creación de modelos de datos y patrones de diseño

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

Creación de modelos de datos y patrones de diseño


• AWSre:Invent 2019: Modelado de datos con DynamoDB— Una charla deAlex DeBrieque le permite
comenzar con los principios del modelado de datos de DynamoDB.

Advanced Design Patterns con la participación de Rick


Houlihan
• AWSre:Invent 2019: Advanced design patterns
• Jeremy Daly comparte sus 12 ideas principales de esta sesión.
• AWSre:Invent 2018: Advanced design patterns
• AWSre:Invent 2017: Advanced design patterns

Note

En cada sesión se explican diferentes casos de uso y ejemplos.

Cursos de formación técnica


• Curso de inmersión profunda de DynamoDB— Un curso de Linux Academy con ayuda del equipo de
Amazon DynamoDB.
• Amazon DynamoDB: Creación de aplicaciones controladas por bases de datos NoSQL— Un curso de
laAWSEquipo de formación y certificación alojado en edX.
• AWSDynamoDB: de principiante a profesional— Un curso de A Cloud Guru.

Herramientas de programación y visualización


• NoSQL Workbench para Amazon DynamoDB: una herramienta visual unificada que proporciona
características de modelado de datos, visualización de datos y desarrollo de consultas para ayudarle a
diseñar, crear, consultar y administrar tablas de DynamoDB.
• Caja de herramientas DynamoDB— Un proyecto de Jeremy Daly que proporciona utilidades útiles para
trabajar con el modelado de datos y en JavaScript y Node.js.
• Dynobase: una herramienta de escritorio que facilita la visualización y el trabajo con las tablas de
DynamoDB, la creación de código de aplicación y la edición de registros con validación en tiempo real.
• Procesador de DynamoDB Streams— Una herramienta sencilla que hace que trabajar conDynamoDB
Streamssuper fácil.

Versión de API 2012-08-10


49
Amazon DynamoDB Guía para desarrolladores
Configuración de DynamoDB Local (versión descargable)

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)

Configuración de DynamoDB Local (versión


descargable)
Con la versión descargable de Amazon DynamoDB puede desarrollar y probar aplicaciones sin obtener
acceso al servicio web de DynamoDB. En lugar de ello, se utiliza una base de datos autónoma que reside
en el equipo. Cuando esté listo para implementar la aplicación en producción, elimine el punto de enlace
local en el código y, a continuación, apunte al servicio web de DynamoDB.

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.

Si prefiere utilizar el servicio web de Amazon DynamoDB en su lugar, consulteConfiguración de


DynamoDB (servicio web) (p. 57).

Temas
• Implementación de DynamoDB localmente en el equipo (p. 50)
• Notas de uso local de DynamoDB (p. 54)

Implementación de DynamoDB localmente en el


equipo
Download Locally

La versión descargable de Amazon DynamoDB se suministra como un archivo ejecutable..jarfile. La


aplicación se ejecuta en Windows, Linux, macOS y otras plataformas compatibles con Java.

Siga estos pasos para configurar y ejecutar DynamoDB en el equipo.

Versión de API 2012-08-10


50
Amazon DynamoDB Guía para desarrolladores
Implementación de

Para configurar DynamoDB en el equipo

1. Descargue DynamoDB gratis desde una de las siguientes ubicaciones.

Región Enlaces de descarga Sumas de comprobación

Asia Pacific (Mumbai) Region .tar.gz | .zip .tar.gz.sha256|.zip.sha256

Asia Pacific (Singapore) .tar.gz | .zip .tar.gz.sha256|.zip.sha256


Region

Asia Pacific (Tokyo) Region .tar.gz | .zip .tar.gz.sha256|.zip.sha256

Europe (Frankfurt) Region .tar.gz | .zip .tar.gz.sha256|.zip.sha256

South America (São Paulo) .tar.gz | .zip .tar.gz.sha256|.zip.sha256


Region

US West (Oregon) Region .tar.gz | .zip .tar.gz.sha256|.zip.sha256

DynamoDB también está disponible como parte deAWS Toolkit for Eclipse. Para obtener más
información, consulte AWS Toolkit for Eclipse.
Important

Para ejecutar DynamoDB en su equipo, debe disponer de Java Runtime Environment


(JRE) versión 8.x o posterior. La aplicación no se ejecuta en versiones anteriores de
JRE.
2. Después de descargar el archivo, extraiga el contenido y copie el directorio extraído en la
ubicación que prefiera.
3. Para iniciar DynamoDB en su equipo, abra una ventana del símbolo del sistema y vaya al
directorio donde ha extraídoDynamoDBLocal.jary escriba el comando siguiente.

java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb

Note

Si utiliza Windows PowerShell, asegúrese de delimitar el nombre del parámetro o todo el


nombre y el valor del siguiente modo:
java -D"java.library.path=./DynamoDBLocal_lib" -jar
DynamoDBLocal.jar
DynamoDB procesa las solicitudes entrantes hasta que lo detiene. Para detener
DynamoDB, escriba Ctrl+C en la ventana del símbolo del sistema.
DynamoDB utiliza el puerto 8000 de forma predeterminada. Si el puerto 8000 no está
disponible, este comando genera una excepción. Para obtener una lista completa de
las opciones de tiempo de ejecución de DynamoDB, incluida la-port, escriba este
comando.
java -Djava.library.path=./DynamoDBLocal_lib -jar
DynamoDBLocal.jar -help
4. Antes de poder acceder a DynamoDB mediante programación o a través deAWS Command
Line Interface(AWS CLI), debe configurar sus credenciales para permitir la autorización para sus
aplicaciones. La versión descargable de DynamoDB requiere cualquier credencial para funcionar,
como se muestra en el siguiente ejemplo.

AWS Access Key ID: "fakeMyKeyId"


Versión de API 2012-08-10
51
Amazon DynamoDB Guía para desarrolladores
Implementación de

AWS Secret Access Key: "fakeSecretAccessKey"

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.

aws dynamodb list-tables --endpoint-url http://localhost:8000

Docker

La versión descargable de Amazon DynamoDB se encuentra disponible como imagen de Docker.


Para obtener más información, consulte dynamodb-local.

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.

Para instalar y ejecutar DynamoDB local con Docker Compose:

1. Descargue e instale Docker Desktop.


2. Copie el código siguiente en un archivo y guárdelo comodocker-compose.yml.

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

Si desea que su aplicación y DynamoDB local estén en contenedores independientes, use el


archivo yaml siguiente.

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:

Versión de API 2012-08-10


52
Amazon DynamoDB Guía para desarrolladores
Implementación de

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

Este script docker-compose.yml crea un contenedor app-node y un contenedor dynamodb-


local. El script ejecuta un comando en elapp-nodeque utiliza elAWS CLIPara conectar
aldynamodb-localy describe los límites de cuenta y tabla.

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

Las secuencias de comandos de YAML requieren que especifique unAWSclave de


acceso y unaAWSclave secreta, pero no se requiere que sean válidasAWSpara acceder
a DynamoDB Local.
3. Ejecute el siguiente comando de línea de comandos:

docker-compose up

Apache Maven

Siga estos pasos para utilizar Amazon DynamoDB en su aplicación como dependencia.

Versión de API 2012-08-10


53
Amazon DynamoDB Guía para desarrolladores
Notas de uso

Para implementar DynamoDB como repositorio de Apache Maven

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

Notas de uso local de DynamoDB


Excepto en lo tocante al punto de enlace, las aplicaciones que se ejecutan con la versión descargable
de Amazon DynamoDB en el sistema deberían funcionar también con el servicio web de DynamoDB. Sin
embargo, si utiliza DynamoDB localmente, debe tener en cuenta lo siguiente:

• Si utiliza la-sharedDb, DynamoDB crea un único archivo de base de datos denominadoshared-local-


instance.db. Todos los programas que se conectan con DynamoDB obtienen acceso a este archivo. Si
elimina el archivo, perderá todos los datos que haya guardado en él.

Versión de API 2012-08-10


54
Amazon DynamoDB Guía para desarrolladores
Notas de uso

• Si omite-sharedDb, el archivo de base de datos se llamamyaccesskeyid_region.db, con elAWSID


de clave de acceso yAWSRegión tal como aparecen en la configuración de la aplicación. Si elimina el
archivo, perderá todos los datos que haya guardado en él.
• Si utiliza la-inMemory, DynamoDB no escribe ningún archivo de base de datos. En lugar de ello, todos
los datos se escriben en la memoria y ninguno de ellos se guarda cuando se cierra DynamoDB.
• Si utiliza la-optimizeDbBeforeStartupopción, también debe especificar la-dbPathpara que
DynamoDB pueda encontrar su archivo de base de datos.
• LaAWSLos SDK para DynamoDB requieren que se especifiquen en la configuración de la aplicación un
valor de clave de acceso y unaAWSValor de región. A menos que utilice la-sharedDbo el-inMemory,
DynamoDB utiliza estos valores para asignar el nombre al archivo de base de datos local. Estos valores
no tienen que ser válidosAWSpara ejecutarse localmente. Sin embargo, tal vez le convenga utilizar
valores válidos para que pueda ejecutar el código en la nube más adelante cambiando simplemente el
punto de enlace que esté utilizando.

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)

Opciones de la línea de comandos


Puede usar las siguientes opciones de línea de comandos con la versión descargable de DynamoDB:

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

DynamoDB utiliza el puerto 8000 de forma predeterminada. Si el puerto 8000 no está


disponible, este comando genera una excepción. Puede usar la opción -port para especificar
otro número de puerto. Para obtener una lista completa de las opciones de tiempo de ejecución
de DynamoDB, incluida la-port, escriba este comando:

Versión de API 2012-08-10


55
Amazon DynamoDB Guía para desarrolladores
Notas de uso

java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -


help
• -sharedDb— Si especifica-sharedDb, DynamoDB utiliza un solo archivo de base de datos, en lugar
de archivos distintos para cada credencial y región.

Configuración del punto de enlace local


De forma predeterminada, elAWSLos SDK y las herramientas utilizan los puntos de enlace del servicio
web de Amazon DynamoDB. Para utilizar los SDK y las herramientas con la versión descargable de
DynamoDB, debe especificar el punto de enlace local:

http://localhost:8000

AWS Command Line Interface


Puede utilizar laAWS Command Line Interface(AWS CLI) para interactuar con DynamoDB descargable.
Por ejemplo, puede utilizarla para realizar todos los pasos de Creación de tablas y carga de datos para
ejemplos de código en DynamoDB (p. 333).

Para obtener acceso a DynamoDB que se ejecuta localmente, use--endpoint-urlParámetro.


A continuación, se muestra un ejemplo del uso deAWS CLIPara obtener una lista de las tablas de
DynamoDB en el equipo.

aws dynamodb list-tables --endpoint-url 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

Para ver ejemplos en otros lenguajes de programación, consulte Introducción a DynamoDB


yAWSSDK de (p. 82).

Diferencias entre DynamoDB descargable y el servicio web de


DynamoDB
La versión descargable de DynamoDB se ha desarrollado únicamente para tareas de desarrollo
y comprobación. Por el contrario, el servicio web de DynamoDB es un servicio administrado con
características de escalabilidad, disponibilidad y durabilidad que resulta ideal para utilizarlo en producción.

La versión descargable de DynamoDB se diferencia del servicio web en lo siguiente:

• AWSRegiones y distintasAWSLas cuentas no son compatibles en el cliente.

Versión de API 2012-08-10


56
Amazon DynamoDB Guía para desarrolladores
Configuración de DynamoDB (servicio web)

• Los ajustes de desempeño aprovisionado se omiten en la versión descargable de DynamoDB, aunque


la versión deCreateTablela operación los requiere. Para CreateTable, puede especificar cualquier
cifra que desee de desempeño provisionado de lectura y escritura, si bien estas cifras no se utilizarán.
Puede llamar a UpdateTable tantas veces como desee al día. Sin embargo, se omiten los cambios en
los valores de desempeño provisionado.
• Las operaciones Scan se llevan a cabo secuencialmente. No se admiten los exámenes en paralelo. Los
parámetros Segment y TotalSegments de la operación Scan se pasan por alto.
• La velocidad de las operaciones de lectura y escritura en los datos de la tabla solamente se ve limitada
por la velocidad del equipo. Las operaciones CreateTable, UpdateTable y DeleteTable se llevan a
cabo de inmediato y el estado de la tabla siempre es ACTIVE. Las operaciones UpdateTable que solo
cambian los ajustes de desempeño provisionado de las tablas y/o los índices secundarios globales se
realizan de inmediato. Si una operación UpdateTable crea o elimina los índices secundarios globales,
estos índices pasan sucesivamente por los estados normales (tales como CREATING o DELETING,
respectivamente) antes de entrar en el estado ACTIVE. La tabla permanece en el estado ACTIVE
durante este tiempo.
• Las operaciones de lectura son de consistencia final. No obstante, debido a la velocidad de DynamoDB
cuando se ejecuta en el equipo, la mayoría de las lecturas parecerán ser de coherencia alta.
• No se realiza el seguimiento de las métricas ni de los tamaños de las colecciones de elementos. En las
respuestas a las operaciones, se devuelven valores Null en lugar de las métricas de las colecciones de
elementos.
• En DynamoDB, existe un límite de 1 MB para los datos devueltos en cada conjunto de resultados.
Tanto el servicio web de DynamoDB como la versión descargable imponen este límite. Sin embargo,
al consultar un índice, el servicio de DynamoDB solo calcula el tamaño de la clave y los atributos
proyectados. En cambio, la versión descargable de DynamoDB calcula el tamaño del elemento
completo.
• Si utiliza DynamoDB Streams, la velocidad a la que se crean las particiones puede ser diferente. En
el servicio web de DynamoDB, el comportamiento de creación de particiones depende en parte de la
actividad de partición de la tabla. Cuando ejecuta DynamoDB localmente, la tabla no se particiona. La
aplicación no debe depender del comportamiento de los fragmentos, puesto que son efímeros en ambos
casos.
• La versión descargable de DynamoDB no lanza TransactionConflictExceptions para API
transaccionales. Le recomendamos que utilice una plataforma de simulación de Java para simular
TransactionConflictExceptions en el controlador de DynamoDB y probar cómo responde la
aplicación a las transacciones conflictivas.
• En el servicio web de DynamoDB, los nombres de las tablas distinguen entre mayúsculas y Una tabla
llamada Authors y otra llamada authors pueden existir como tablas independientes. En la versión
descargable, los nombres de las tablas no distinguen entre mayúsculas y minúsculas y si intenta crear
estas dos tablas se producirá un error.

Configuración de DynamoDB (servicio web)


Para utilizar el servicio web de Amazon DynamoDB:

1. Inscripción enAWS. (p. 58)


2. Obtenga unaAWSclave de acceso (p. 58)(utilizado para obtener acceso a DynamoDB mediante
programación).
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).

Versión de API 2012-08-10


57
Amazon DynamoDB Guía para desarrolladores
Inscripción en AWS

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.

Para inscribirse en AWS

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.

Obtención deAWSClave de acceso


Antes de poder acceder a DynamoDB mediante programación o a través deAWS Command Line
Interface(AWS CLI), debe disponer de unaAWSClave de acceso de . No necesita una clave de acceso si
piensa utilizar solamente la consola de DynamoDB.

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.

Para crear claves de acceso para un usuario de IAM

1. Inicie sesión en la AWS Management Console y abra la consola de IAM en https://


console.aws.amazon.com/iam/.
2. En el panel de navegación, seleccione Users.
3. Elija el nombre del usuario cuyas claves de acceso que desea crear y, a continuación, elija la
opciónCredencialesPestaña.
4. En el navegadorClaves de acceso, elijaCrear clave de acceso.
5. Para ver el nuevo key pair de acceso, elijaMostrar. No podrá obtener acceso de nuevo a la clave
de acceso secreta cuando este cuadro de diálogo se cierre. Sus credenciales tendrán el aspecto
siguiente:

• ID de clave de acceso: AKIAIOSFODNN7EXAMPLE


• : wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
6. Para descargar el par de claves, elija Download .csv file (Descargar archivo .csv). Almacene las claves
en un lugar seguro. No podrá obtener acceso de nuevo a la clave de acceso secreta cuando este
cuadro de diálogo se cierre.

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.

Versión de API 2012-08-10


58
Amazon DynamoDB Guía para desarrolladores
Configuración de las credenciales

Temas relacionados

• ¿Qué es IAM?en laGuía del usuario de IAM


• AWSCredenciales de seguridad deinAWSReferencia general de

Configuración de las credenciales


Antes de poder acceder a DynamoDB mediante programación o a través deAWS CLIPara permitir la
autorización para sus aplicaciones, debe configurar sus credenciales.

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

Versión de API 2012-08-10


59
Amazon DynamoDB Guía para desarrolladores
Mediante la consola

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.

Pude utilizar la consola para hacer lo siguiente en DynamoDB: DynamoDB

• 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:

• Información generalAdministrar los detalles de las secuencias y tablas y administrar secuencias y


Tiempo de vida (TTL).
• Items: permite administrar elementos y llevar a cabo consultas y exámenes.
• MétricasMonitoree las métricas de Amazon CloudWatch.
• Alarms: permite administrar las alarmas de CloudWatch.

Versión de API 2012-08-10


60
Amazon DynamoDB Guía para desarrolladores
Trabajo con las preferencias del usuario

• Capacity: permite modificar la capacidad aprovisionada de una tabla.


• Índices: permite administrar los índices secundarios globales.
• Triggers: permite administrar los disparadores para conectar secuencias de DynamoDB con funciones
Lambda.
• Access control: permite configurar un control de acceso preciso con las identidades web federadas.
• Tags: permite aplicar etiquetas a los recursos para organizarlos e identificarlos mejor.

Trabajo con las preferencias del usuario


Puede configurar algunos ajustes predeterminados en la consola de Amazon DynamoDB. Por ejemplo,
puede cambiar el tipo de consulta predeterminado que se usa al obtener acceso a la pestaña Items
(Elementos). Si ha iniciado sesión en la consola como usuario de IAM, puede almacenar información
sobre cómo prefiere utilizar la consola. Esta información, denominada también preferencias del usuario,
se almacena y se aplica cada vez que utilice la consola. Cada vez que obtiene acceso a la consola de
DynamoDB, estas preferencias se aplican a todas tablas de todasAWSRegiones para su usuario de IAM.
No son específicas de la tabla ni de la región. No tienen ningún efecto en sus interacciones con laAWS
CLI, la API de DynamoDB u otros servicios que interactúan con DynamoDB.

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.

Las preferencias de usuario son las siguientes:

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

Ver y guardar las preferencias del usuario


Puede ver y cambiar las preferencias del usuario para la consola de DynamoDB. Esta configuración solo
se aplica al usuario de IAM en la consola de DynamoDB. No tienen ningún efecto en otros usuarios de IAM
en laAWSaccount.

Versión de API 2012-08-10


61
Amazon DynamoDB Guía para desarrolladores
Mediante AWS CLI

Para ver y guardar las preferencias en la consola de DynamoDB para el usuario de IAM

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.

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.

Aplique alguna de las siguientes acciones:

• Para guardar y aplicar los cambios, elija Save (Guardar).


• Para ver la configuración predeterminada de la consola de DynamoDB, elijaRestaurar. Estos valores
predeterminados se aplican si elige Save (Guardar).

Los ajustes predeterminados son los siguientes:


• Modo de vista de detalles de la tabla: Vertical
• Mostrar barra de navegación: Sí
• Default entry page (Página predeterminada Panel
• Modo de editor de elementos: Árbol
• Items default query type (Tipo de Examen
• Operación de exploración automática al acceder a la pestaña de elementos: Sí
• Para volver a la página de la consola en la que estaba anteriormente, elija Back (Atrás). O bien,
elijaPanelPara ir a la página del panel de DynamoDB.

Mediante AWS CLI


Puede utilizar laAWS Command Line Interface(AWS CLI) para controlar múltiplesAWSdesde la línea de
comandos y automatizarlos mediante scripts. Puede usar la AWS CLI para operaciones ad-hoc, como
crear una tabla. También puede usarla para incluir operaciones de Amazon DynamoDB en scripts de
utilidades.

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)

Descarga y configuración de la AWS CLI


LaAWS CLIestá disponible en.http://aws.amazon.com/cli. Se ejecuta en Windows, macOS o Linux.
Después de descargar la AWS CLI, siga estos pasos para instalarla y configurarla:

1. Vaya a laAWS Command Line InterfaceGuía del usuario.


2. Siga las instrucciones paraInstalación de laAWS CLIyConfiguración dAWS CLI.
Versión de API 2012-08-10
62
Amazon DynamoDB Guía para desarrolladores
Mediante laAWS CLIcon DynamoDB

Mediante laAWS CLIcon DynamoDB


El formato de la línea de comandos se compone de un nombre de operación de DynamoDB seguido de los
parámetros de dicha operación. La AWS CLI admite la sintaxis abreviada de los valores de los parámetros,
además de JSON.

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.

aws dynamodb create-table \


--table-name Music \
--attribute-definitions \
AttributeName=Artist,AttributeType=S \
AttributeName=SongTitle,AttributeType=S \
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=1,WriteCapacityUnits=1

Los comandos siguientes añaden nuevos elementos a la tabla. En estos ejemplos se usa una combinación
de sintaxis abreviada y JSON.

aws dynamodb put-item \


--table-name Music \
--item \
'{"Artist": {"S": "No One You Know"}, "SongTitle": {"S": "Call Me Today"},
"AlbumTitle": {"S": "Somewhat Famous"}}' \
--return-consumed-capacity TOTAL

aws dynamodb put-item \


--table-name Music \
--item '{ \
"Artist": {"S": "Acme Band"}, \
"SongTitle": {"S": "Happy Day"}, \
"AlbumTitle": {"S": "Songs About Life"} }' \
--return-consumed-capacity TOTAL

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"
}
}

Versión de API 2012-08-10


63
Amazon DynamoDB Guía para desarrolladores
Mediante laAWS CLIcon DynamoDB descargable

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.

aws dynamodb query --table-name Music --key-conditions file://key-conditions.json

Mediante laAWS CLIcon DynamoDB descargable


LaAWS CLITambién puede interactuar con DynamoDB (versión descargable) que se ejecuta en su equipo.
Para ello, agregue el parámetro siguiente a cada comando:

--endpoint-url http://localhost:8000

En e siguiente ejemplo se usa la AWS CLI para mostrar las tablas de una base de datos local:

aws dynamodb list-tables --endpoint-url http://localhost:8000

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.

LaAWSLos SDK de proporcionan un amplio soporte para DynamoDB enJava,JavaScript en el


navegador,.NET,Node.js,PHP,Python,Ruby,C ++,Go,Android, yiOS. Para comenzar rápidamente a trabajar
con estos lenguajes, consulte Introducción a DynamoDB yAWSSDK de (p. 82).

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

Uso de NoSQL Workbench para DynamoDB


También puede obtener acceso DynamoDB, mediante laDescargary utilizando laNoSQL Workbench para
DynamoDB (p. 840).

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.

Versión de API 2012-08-10


64
Amazon DynamoDB Guía para desarrolladores
Rangos de direcciones IP

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

Los rangos de direcciones IP no se aplican a DynamoDB Streams ni a DynamoDB Accelerator


(DAX).

Versión de API 2012-08-10


65
Amazon DynamoDB Guía para desarrolladores
Conceptos básicos

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)

Conceptos básicos de DynamoDB


Antes de comenzar, debe familiarizarse con los conceptos básicos de Amazon DynamoDB. Para obtener
más información, consulteComponentes básicos de DynamoDB.

A continuación, siga por elRequisitos previospara obtener más información sobre la configuración de
DynamoDB.

Requisitos previos - Tutorial de introducción


Antes de iniciar el tutorial de Amazon DynamoDB, siga los pasos que se indican enConfiguración de
DynamoDB. A continuación, siga por el Paso 1: Crear una tabla (p. 66).
Note

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

Paso 1: Crear una tabla


En este paso va a crear unMusicTabla INTO EN Amazon DynamoDB. La tabla tiene las características
siguientes:

• Clave de partición:Artist
• Clave de ordenación:SongTitle

Versión de API 2012-08-10


66
Amazon DynamoDB Guía para desarrolladores
Paso 1: Crear una tabla

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 Management Console


Para crear un nuevoMusicTabla INTO mediante la consola de DynamoDB:

1. Inicie sesión enAWS Management Consoley abra la consola de DynamoDB enhttps://


console.aws.amazon.com/dynamodb/.
2. En el panel de navegación del lado izquierdo de la consola, elija Dashboard (Panel).
3. En el lado derecho de la consola, elija Create Table (Crear tabla).

4. Introduzca los datos siguientes para la tabla:

a. Escriba Music como nombre de la tabla.


b. Escriba Artist como clave de partición.
c. Elija Add sort key (Añadir clave de ordenación).
d. Escriba SongTitle como clave de clasificación.
5. Elija Create (Crear) para crear la tabla.

Versión de API 2012-08-10


67
Amazon DynamoDB Guía para desarrolladores
Paso 1: Crear una tabla

AWS CLI
En el siguiente ejemplo de la AWS CLI, se crea una tabla denominada Music con create-table.

aws dynamodb create-table \


--table-name Music \
--attribute-definitions \
AttributeName=Artist,AttributeType=S \
AttributeName=SongTitle,AttributeType=S \
--key-schema \
AttributeName=Artist,KeyType=HASH \
AttributeName=SongTitle,KeyType=RANGE \
--provisioned-throughput \
ReadCapacityUnits=10,WriteCapacityUnits=5

El uso de create-table devuelve el siguiente resultado de ejemplo.

{
"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
}
}

Observe que el valor del campo TableStatus es CREATING.

Para comprobar que DynamoDB ha terminado de crear elMusic, utilice la tabladescribe-


tableComando de.

aws dynamodb describe-table --table-name Music | grep TableStatus

Versión de API 2012-08-10


68
Amazon DynamoDB Guía para desarrolladores
Paso 2: Escribir datos

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

Paso 2: Escribir datos en una tabla mediante la


consola o la.AWS CLI
En este paso, añadirá dos elementos a la tabla Music que creó en el Paso 1: Crear una tabla (p. 66).

Para obtener más información sobre las operaciones de escritura, consulte Escritura de un
elemento (p. 411).

AWS Management Console


Siga estos pasos para escribir datos en elMusicTabla INTO mediante la consola de DynamoDB.

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.


2. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas).
3. En la lista de tablas, elija la tabla Music (Música).
4. Elija la pestaña Items (Elementos) para la tabla Music (Música).
5. En la pestaña Items (Elementos), elija Create item (Crear elemento).

6. Elija el símbolo del signo más (+) situado junto a SongTitle.


7. Elija Append (Añadir) y, a continuación, elija Number (Número). Asigne al campo el nombre Awards
(Premios).

Versión de API 2012-08-10


69
Amazon DynamoDB Guía para desarrolladores
Paso 2: Escribir datos

8. Repita este proceso para crear un campo denominado AlbumTitle de tipo String (Cadena).
9. Elija los valores siguientes para el elemento:

a. En Artist (Artista), escriba el valor No One You Know.


b. En SongTitle, escriba Call Me Today.
c. En AlbumTitle, escriba Somewhat Famous.
d. En Awards (Premios), escriba 1.
10. Elija Save (Guardar).

11. Repita este proceso y cree otro elemento con los valores siguientes:

a. En Artist (Artista), escriba Acme Band.

Versión de API 2012-08-10


70
Amazon DynamoDB Guía para desarrolladores
Paso 3: Leer datos

b. En SongTitle escriba Happy Day.


c. En AlbumTitle, escriba Songs About Life.
d. En Awards (Premios), escriba 10.

AWS CLI
En el siguiente ejemplo de la AWS CLI crea dos elementos en la tabla Music utilizando put-item.

aws dynamodb put-item \


--table-name Music \
--item \
'{"Artist": {"S": "No One You Know"}, "SongTitle": {"S": "Call Me Today"},
"AlbumTitle": {"S": "Somewhat Famous"}, "Awards": {"N": "1"}}'

aws dynamodb put-item \


--table-name Music \
--item \
'{"Artist": {"S": "Acme Band"}, "SongTitle": {"S": "Happy Day"}, "AlbumTitle":
{"S": "Songs About Life"}, "Awards": {"N": "10"} }'

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

Paso 3: Lectura de datos de una tabla


En este paso, volverá a leer un elemento que se creó en el Paso 2: Escribir datos en una tabla mediante
la consola o la.AWS CLI (p. 69). Puede utilizar la consola de DynamoDB o elAWS CLIPara leer un
elemento de laMusictabla especificandoArtistySongTitle.

Para obtener más información sobre las operaciones de lectura en DynamoDB, consulte.Lectura de un
elemento (p. 411).

AWS Management Console


Siga estos pasos para leer los datos deMusicTabla INTO mediante la consola de DynamoDB.

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.


2. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas).
3. Elija la tabla Music (Música) en la lista de tablas.
4. Elija el iconoElementospara la tabla Music (Música).
5. En la pestaña Items (Elementos), puede ver la lista de los elementos almacenados en la tabla,
ordenados por los campos Artist y SongTitle.

El primer elemento de la lista es el que tiene la.Artist Banda Acmey laSongTitle Día feliz.

Versión de API 2012-08-10


71
Amazon DynamoDB Guía para desarrolladores
Paso 4: Actualización de datos

AWS CLI
En el siguiente ejemplo de la AWS CLI, se lee un elemento de la tabla Music utilizando get-item.
Note

El comportamiento predeterminado de DynamoDB es el de lectura consistente final. El parámetro


consistent-read se utiliza a continuación para demostrar las lecturas de consistencia alta.

aws dynamodb get-item --consistent-read \


--table-name Music \
--key '{ "Artist": {"S": "Acme Band"}, "SongTitle": {"S": "Happy Day"}}'

El uso de get-item devuelve el siguiente resultado de ejemplo.

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

Paso 4: Actualización de datos de una tabla


En este paso, actualizará un elemento que creó en el Paso 2: Escribir datos en una tabla mediante
la consola o la.AWS CLI (p. 69). Puede utilizar la consola de DynamoDB o elAWS CLIPara

Versión de API 2012-08-10


72
Amazon DynamoDB Guía para desarrolladores
Paso 4: Actualización de datos

actualizar elAlbumTitlede un elemento en elMusictabla especificandoArtist,SongTitle, y la


actualizaciónAlbumTitle.

Para obtener más información sobre las operaciones de escritura, consulte Escritura de un
elemento (p. 411).

AWS Management Console


Puede utilizar la consola de DynamoDB para actualizar los datos de la.MusicTabla INTO

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.


2. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas).
3. Elija la tabla Music (Música) en la lista de tablas.
4. Seleccione la pestaña Items (Elementos) para la tabla Music.
5. Elija el elemento cuyoArtistEl valor esBanda AcmeySongTitleEl valor esDía feliz.
6. Actualice el valor de AlbumTitle a Updated Album Title y, a continuación, elija Save (Guardar).

La siguiente imagen muestra el elemento actualizado en la consola.

AWS CLI
En el siguiente ejemplo de la AWS CLI, se actualiza un elemento de la tabla Music utilizando update-
item.

aws dynamodb update-item \


--table-name Music \
--key '{ "Artist": {"S": "Acme Band"}, "SongTitle": {"S": "Happy Day"}}' \
--update-expression "SET AlbumTitle = :newval" \
--expression-attribute-values '{":newval":{"S":"Updated Album Title"}}' \
--return-values ALL_NEW

Versión de API 2012-08-10


73
Amazon DynamoDB Guía para desarrolladores
Paso 5: Consulta de los datos

El uso de update-item devuelve el siguiente resultado de ejemplo.

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

Paso 5: Consulta de los datos de una tabla


En este paso, consultará los datos que escribió en la tabla Music en el the section called “Paso 2: Escribir
datos” (p. 69) especificando el campo Artist.

Para obtener más información sobre las operaciones de consulta, consulte Uso de consultas en
DynamoDB (p. 497).

AWS Management Console


Siga estos pasos para utilizar la consola de DynamoDB para consultar datos en elMusicTabla INTO

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.


2. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas).
3. Elija la tabla Music (Música) en la lista de tablas.
4. Seleccione la pestaña Items (Elementos) para la tabla Music.
5. En la lista desplegable, elija Query (Consulta).

6. En Partition key (Clave de partición), escriba Acme Band y, a continuación, elija Start search (Iniciar
búsqueda).

Versión de API 2012-08-10


74
Amazon DynamoDB Guía para desarrolladores
Paso 5: Consulta de los datos

AWS CLI
En el siguiente ejemplo de la AWS CLI, se consulta un elemento de la tabla Music utilizando query.

aws dynamodb query \


--table-name Music \
--key-condition-expression "Artist = :name" \
--expression-attribute-values '{":name":{"S":"Acme Band"}}'

El uso de query devuelve el siguiente resultado de ejemplo.

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

Versión de API 2012-08-10


75
Amazon DynamoDB Guía para desarrolladores
Paso 6: Creación de un índice secundario global

Paso 6: Creación de un índice secundario global


En este paso, creará un índice secundario global para la tabla Music que creó en el Paso 1: Crear una
tabla (p. 66).

Para obtener más información sobre los índices secundarios globales, consulte Uso de índices
secundarios en DynamoDB (p. 570).

AWS Management Console


Para utilizar la consola de Amazon DynamoDB para crear un índice secundario globalAlbumTitle-
indexpara laMusicTabla INTO:

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.


2. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas).
3. Elija la tabla Music (Música) en la lista de tablas.
4. Elija la pestaña Indexes (Índices) para la tabla Music (Música).
5. Elija Create index (Crear índice).

6. En Partition key (Clave de partición), escriba AlbumTitle y, a continuación, elija Create index (Crear
índice).

Versión de API 2012-08-10


76
Amazon DynamoDB Guía para desarrolladores
Paso 6: Creación de un índice secundario global

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.

aws dynamodb update-table \


--table-name Music \
--attribute-definitions AttributeName=AlbumTitle,AttributeType=S \
--global-secondary-index-updates \
"[{\"Create\":{\"IndexName\": \"AlbumTitle-index\",\"KeySchema\":[{\"AttributeName
\":\"AlbumTitle\",\"KeyType\":\"HASH\"}], \
\"ProvisionedThroughput\": {\"ReadCapacityUnits\": 10, \"WriteCapacityUnits\": 5
},\"Projection\":{\"ProjectionType\":\"ALL\"}}}]"

El uso de update-table devuelve el siguiente resultado de ejemplo.

{
"TableDescription": {
"TableArn": "arn:aws:dynamodb:us-west-2:522194210714:table/Music",
"AttributeDefinitions": [
{
"AttributeName": "AlbumTitle",
"AttributeType": "S"
},
{
"AttributeName": "Artist",
"AttributeType": "S"

Versión de API 2012-08-10


77
Amazon DynamoDB Guía para desarrolladores
Paso 6: Creación de un índice secundario global

},
{
"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
}
}

Observe que el valor del campo IndexStatus es CREATING.

Para comprobar que DynamoDB ha terminado de crear elAlbumTitle-indexíndice secundario global,


utilice eldescribe-tableComando de.

aws dynamodb describe-table --table-name Music | grep IndexStatus

Este comando devuelve el siguiente resultado. El índice está listo para su uso cuando el valor del campo
IndexStatus devuelto se establece en ACTIVE.

Versión de API 2012-08-10


78
Amazon DynamoDB Guía para desarrolladores
Paso 7: Consulta del índice secundario global

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

Paso 7: Consulta del índice secundario global


En este paso, se consulta un índice secundario global en la pestañaMusicmediante la consola de Amazon
DynamoDB o elAWS CLI.

Para obtener más información sobre los índices secundarios globales, consulte Uso de índices
secundarios en DynamoDB (p. 570).

AWS Management Console


Siga estos pasos para utilizar la consola de DynamoDB para consultar datos mediante la.AlbumTitle-
indexíndice secundario global.

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.


2. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas).
3. Elija la tabla Music (Música) en la lista de tablas.
4. Elija el iconoElementospara la tabla Music (Música).
5. En la lista desplegable, elija Query (Consulta).

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

Versión de API 2012-08-10


79
Amazon DynamoDB Guía para desarrolladores
Paso 8: (Opcional) Limpieza

AWS CLI
En el siguiente ejemplo de la AWS CLI, se consulta el índice secundario global AlbumTitle-index de la
tabla Music.

aws dynamodb query \


--table-name Music \
--index-name AlbumTitle-index \
--key-condition-expression "AlbumTitle = :name" \
--expression-attribute-values '{":name":{"S":"Somewhat Famous"}}'

El uso de query devuelve el siguiente resultado de ejemplo.

{
"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
}

Paso 8: (Opcional) Limpieza de recursos


Si ya no necesita la tabla de Amazon DynamoDB que creó para el tutorial, puede eliminarla. Este paso le
permite asegurarse de que no se le cobre por los recursos que no vaya a utilizar. Puede utilizar la consola
de DynamoDB o elAWS CLIPara eliminar elMusicTabla que creó enPaso 1: Crear una tabla (p. 66).

Para obtener más información sobre las operaciones con tablas en DynamoDB, consulte.Uso de tablas y
datos en DynamoDB (p. 344).

AWS Management Console


Para eliminar la tabla Music mediante la consola:

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.


2. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas).
3. Elija la tabla Music (Música) en la lista de tablas.
4. Elija la pestaña Indexes (Índices) para la tabla Music.
5. Elija Delete table (Eliminar tabla).

Versión de API 2012-08-10


80
Amazon DynamoDB Guía para desarrolladores
Pasos siguientes

AWS CLI
En el siguiente ejemplo de la AWS CLI, se elimina la tabla Music utilizando delete-table.

aws dynamodb delete-table --table-name Music

Introducción a DynamoDB: Pasos siguientes


Para obtener más información sobre cómo utilizar Amazon DynamoDB, consulte los siguientes 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 índices secundarios en DynamoDB (p. 570)
• Trabajo con transacciones (p. 689)
• Accelerator en memoria con DynamoDB Accelerator (DAX) (p. 722)
• Introducción a DynamoDB yAWSSDK de (p. 82)
• Programación con DynamoDB y elAWSSDK de (p. 214)

Versión de API 2012-08-10


81
Amazon DynamoDB Guía para desarrolladores
Java y DynamoDB

Introducción a DynamoDB yAWSSDK


de
Esta sección contiene tutoriales prácticos para ayudarle a conocer Amazon DynamoDB. Le recomendamos
que realice alguno de los tutoriales específicos de los distintos lenguajes. Los ejemplos de código de estos
tutoriales se puede ejecutar en la versión descargable de DynamoDB o en el servicio web de DynamoDB.
Note

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)

Introducción a Java y DynamoDB


En este tutorial, utilizaremos laAWS SDK for JavaPara 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.

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.

Requisitos previos del tutorial


• Descargue y ejecute DynamoDB en el equipo. Para obtener más información, consulte Configuración de
DynamoDB Local (versión descargable) (p. 50).

DynamoDB descargable) también está disponible como parte deAWS Toolkit for Eclipse. Para obtener
más información, consulte AWS Toolkit for Eclipse.
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 web de DynamoDB, consulte
laSummary (p. 101).

Versión de API 2012-08-10


82
Amazon DynamoDB Guía para desarrolladores
Paso 1: Crear una tabla

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

Paso 1: Creación de una tabla usando Java y


DynamoDB
En este paso, se crea una tabla denominada Movies. La clave principal de la tabla se compone de los
siguientes atributos:

• year: clave de partición. El valor de ScalarAttributeType es N si es numérico.


• title: clave de ordenación. El valor de ScalarAttributeType es S si es de cadena.

1. Copie el siguiente programa y péguelo en su entorno de desarrollo de 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.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;

public class MoviesCreateTable {

public static void main(String[] args) throws Exception {

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()


.withEndpointConfiguration(new
AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "us-west-2"))

Versión de API 2012-08-10


83
Amazon DynamoDB Guía para desarrolladores
Paso 2: Carga de ejemplos de datos

.build();

DynamoDB dynamoDB = new DynamoDB(client);

String tableName = "Movies";

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

Paso 2: Cargue datos de muestra con Java y


DynamoDB
En este paso, se rellena la tabla Movies con ejemplos de datos.

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.

Versión de API 2012-08-10


84
Amazon DynamoDB Guía para desarrolladores
Paso 2: Carga de ejemplos de datos

[
{
"year" : ... ,
"title" : ... ,
"info" : { ... }
},
{
"year" : ...,
"title" : ...,
"info" : { ... }
},

...

En los datos de JSON, tenga en cuenta lo siguiente:

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

A continuación, se muestra un ejemplo de datos de películas.

{
"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"
]
}
}

Paso 2.1: Descargue el archivo de datos


1. Descargue el archivo de datos de ejemplo: moviedata.zip
2. Extraiga el archivo de datos (moviedata.json) del archivo comprimido.
3. Copie y pegue el archivo moviedata.json en el directorio actual.

Versión de API 2012-08-10


85
Amazon DynamoDB Guía para desarrolladores
Paso 2: Carga de ejemplos de datos

Paso 2.2: Cargue los ejemplos de datos en la tabla Movies


Después de descargar los datos de ejemplo, puede ejecutar el programa siguiente para rellenar la tabla
Movies.

1. Copie el siguiente programa y péguelo en su entorno de desarrollo de 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.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;

public class MoviesLoadData {

public static void main(String[] args) throws Exception {

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()


.withEndpointConfiguration(new
AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "us-west-2"))
.build();

DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("Movies");

JsonParser parser = new JsonFactory().createParser(new File("moviedata.json"));

JsonNode rootNode = new ObjectMapper().readTree(parser);


Iterator<JsonNode> iter = rootNode.iterator();

ObjectNode currentNode;

while (iter.hasNext()) {
currentNode = (ObjectNode) iter.next();

int year = currentNode.path("year").asInt();


String title = currentNode.path("title").asText();

Versión de API 2012-08-10


86
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

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.

Paso 3: Creación, lectura, actualización y eliminación


de elementos
En este paso, se llevan a cabo operaciones de lectura y escritura con un elemento de la tabla Movies.

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)

Paso 3.1: Creación de un elemento nuevo


En este paso, agregamos un elemento nuevo a la tabla Movies.

1. Copie el siguiente programa y péguelo en su entorno de desarrollo de 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

Versión de API 2012-08-10


87
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

* 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;

public class MoviesItemOps01 {

public static void main(String[] args) throws Exception {

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()


.withEndpointConfiguration(new
AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "us-west-2"))
.build();

DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("Movies");

int year = 2015;


String title = "The Big New Movie";

final Map<String, Object> infoMap = new HashMap<String, Object>();


infoMap.put("plot", "Nothing happens at all.");
infoMap.put("rating", 0);

try {
System.out.println("Adding a new item...");
PutItemOutcome outcome = table
.putItem(new Item().withPrimaryKey("year", year, "title",
title).withMap("info", infoMap));

System.out.println("PutItem succeeded:\n" + outcome.getPutItemResult());

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

Versión de API 2012-08-10


88
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

Paso 3.2: Lea un elemento


En el programa anterior, hemos agregado el elemento siguiente a la tabla.

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

1. Copie el siguiente programa y péguelo en su entorno de desarrollo de 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.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;

public class MoviesItemOps02 {

public static void main(String[] args) throws Exception {

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()


.withEndpointConfiguration(new
AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "us-west-2"))
.build();

DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("Movies");

int year = 2015;


String title = "The Big New Movie";

GetItemSpec spec = new GetItemSpec().withPrimaryKey("year", year, "title",


title);

Versión de API 2012-08-10


89
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

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

}
}

2. Compile y ejecute el programa.

Paso 3.3: Actualización de un elemento


Puede utilizar el método updateItem para modificar un elemento existente. Puede actualizar los valores
de los atributos existentes, así como agregar atributos nuevos o eliminarlos.

En este ejemplo, se llevan a cabo las siguientes actualizaciones:

• Cambie el valor de los atributos existentes (rating, plot).


• Agregue un nuevo atributo de lista (actors) al mapa info existente.

El elemento cambia de lo siguiente:

{
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"]
}
}

1. Copie el siguiente programa y péguelo en su entorno de desarrollo de 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/

Versión de API 2012-08-10


90
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

*
* 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;

public class MoviesItemOps03 {

public static void main(String[] args) throws Exception {

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()


.withEndpointConfiguration(new
AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "us-west-2"))
.build();

DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("Movies");

int year = 2015;


String title = "The Big New Movie";

UpdateItemSpec updateItemSpec = new UpdateItemSpec().withPrimaryKey("year",


year, "title", title)
.withUpdateExpression("set info.rating = :r, info.plot=:p, info.actors=:a")
.withValueMap(new ValueMap().withNumber(":r", 5.5).withString(":p",
"Everything happens all at once.")
.withList(":a", Arrays.asList("Larry", "Moe", "Curly")))
.withReturnValues(ReturnValue.UPDATED_NEW);

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.

Versión de API 2012-08-10


91
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

LaReturnValuesEl parámetro indica a Amazon DynamoDB que devuelva únicamente los


atributos actualizados (UPDATED_NEW).
2. Compile y ejecute el programa.

Paso 3.4: Incremento de un contador atómico


DynamoDB adores atómicos. Utilice el método updateItem para aumentar o reducir el valor de un
atributo sin interferir con otras solicitudes de escritura. Todas las solicitudes de escritura se aplican en el
orden en que se reciben.

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.

1. Copie el siguiente programa y péguelo en su entorno de desarrollo de 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.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;

public class MoviesItemOps04 {

public static void main(String[] args) throws Exception {

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()


.withEndpointConfiguration(new
AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "us-west-2"))
.build();

DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("Movies");

int year = 2015;


String title = "The Big New Movie";

UpdateItemSpec updateItemSpec = new UpdateItemSpec().withPrimaryKey("year",


year, "title", title)
.withUpdateExpression("set info.rating = info.rating + :val")

Versión de API 2012-08-10


92
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

.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());
}
}
}

2. Compile y ejecute el programa.

Paso 3.5: Actualización de un elemento (condicionalmente)


El programa siguiente muestra cómo usar UpdateItem con una condición. Si la condición se evalúa en
true (verdadero), la actualización se lleva a cabo correctamente; de lo contrario, la actualización no se
realiza.

En este caso, el elemento de película se actualiza solamente si hay más de tres actores.

1. Copie el siguiente programa y péguelo en su entorno de desarrollo de 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.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;

public class MoviesItemOps05 {

public static void main(String[] args) throws Exception {

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()

Versión de API 2012-08-10


93
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

.withEndpointConfiguration(new
AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "us-west-2"))
.build();

DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("Movies");

int year = 2015;


String title = "The Big New Movie";

UpdateItemSpec updateItemSpec = new UpdateItemSpec()


.withPrimaryKey(new PrimaryKey("year", year, "title",
title)).withUpdateExpression("remove info.actors[0]")
.withConditionExpression("size(info.actors) > :num").withValueMap(new
ValueMap().withNumber(":num", 3))
.withReturnValues(ReturnValue.UPDATED_NEW);

// Conditional update (we expect this to fail)


try {
System.out.println("Attempting a conditional update...");
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());
}
}
}

2. Compile y ejecute el programa.

Debe producirse un error en el programa y mostrar el mensaje siguiente:

The conditional request failed (Error en la solicitud condicional)

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.

.withConditionExpression("size(info.actors) >= :num")

Ahora, la condición es mayor o igual que 3 en lugar de mayor que 3.


4. Compile y ejecute el programa. Ahora, la operación UpdateItem debería realizarse correctamente.

Paso 3.6: Eliminación de un elemento


Puede utilizar el método deleteItem para eliminar un elemento especificando su clave principal. También
puede incluir una instrucción ConditionExpression para evitar que se elimine el elemento si no se
cumple la condición.

En el siguiente ejemplo, se intenta eliminar un elemento de película determinado si su calificación es igual


o menor que 5.

1. Copie el siguiente programa y péguelo en su entorno de desarrollo de Java.

/**

Versión de API 2012-08-10


94
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

* 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.spec.DeleteItemSpec;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;

public class MoviesItemOps06 {

public static void main(String[] args) throws Exception {

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()


.withEndpointConfiguration(new
AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "us-west-2"))
.build();

DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("Movies");

int year = 2015;


String title = "The Big New Movie";

DeleteItemSpec deleteItemSpec = new DeleteItemSpec()


.withPrimaryKey(new PrimaryKey("year", year, "title",
title)).withConditionExpression("info.rating <= :val")
.withValueMap(new ValueMap().withNumber(":val", 5.0));

// Conditional delete (we expect this to fail)

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

2. Compile y ejecute el programa.

Debe producirse un error en el programa y mostrar el mensaje siguiente:

Versión de API 2012-08-10


95
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

The conditional request failed (Error en la solicitud condicional)

Esto se debe a que la calificación de esta película concreta es mayor que 5.


3. Modifique el programa para eliminar la condición de DeleteItemSpec.

DeleteItemSpec deleteItemSpec = new DeleteItemSpec()


.withPrimaryKey(new PrimaryKey("year", 2015, "title", "The Big New Movie"));

4. Compile y ejecute el programa. Ahora, la eliminación se llevará a cabo correctamente porque se ha


eliminado la condición.

Paso 4: Consulta y examen de los datos


Puede utilizar el método query para recuperar datos de una tabla. Debe especificar un valor de clave de
partición. La clave de ordenación es opcional.

La clave principal de la tabla Movies consta de:

• year: clave de partición. El tipo de atributo es Number.


• title: clave de ordenación. El tipo de atributo es String.

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)

Paso 4.1: Consulta


El código incluido en este paso lleva a cabo las siguientes consultas:

• Recuperar todas las películas estrenadas el año (year) 1985.


• Recuperar todas las películas estrenadas el año (year) 1992, cuyo título (title) comience por las
letras de la "A" a la "L".

1. Copie el siguiente programa y péguelo en su entorno de desarrollo de 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

Versión de API 2012-08-10


96
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

*
* 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;

public class MoviesQuery {

public static void main(String[] args) throws Exception {

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()


.withEndpointConfiguration(new
AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "us-west-2"))
.build();

DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("Movies");

HashMap<String, String> nameMap = new HashMap<String, String>();


nameMap.put("#yr", "year");

HashMap<String, Object> valueMap = new HashMap<String, Object>();


valueMap.put(":yyyy", 1985);

QuerySpec querySpec = new QuerySpec().withKeyConditionExpression("#yr


= :yyyy").withNameMap(nameMap)
.withValueMap(valueMap);

ItemCollection<QueryOutcome> items = null;


Iterator<Item> iterator = null;
Item item = null;

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

Versión de API 2012-08-10


97
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

System.err.println(e.getMessage());
}

valueMap.put(":yyyy", 1992);
valueMap.put(":letter1", "A");
valueMap.put(":letter2", "L");

querySpec.withProjectionExpression("#yr, title, info.genres, info.actors[0]")


.withKeyConditionExpression("#yr = :yyyy and title between :letter1
and :letter2").withNameMap(nameMap)
.withValueMap(valueMap);

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

Paso 4.2: Examen


El método scan lee cada uno de los elementos de la tabla y devuelve todos los datos de la tabla. Puede
proporcionar una expresión filter_expression opcional para que solamente se devuelvan los

Versión de API 2012-08-10


98
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

elementos que coinciden con los criterios. No obstante, el filtro solo se aplica después de haber examinado
toda la tabla.

El programa siguiente examina la tabla Movies en su totalidad, que contiene aproximadamente


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

1. Copie el siguiente programa y péguelo en su entorno de desarrollo de 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.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;

public class MoviesScan {

public static void main(String[] args) throws Exception {

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()


.withEndpointConfiguration(new
AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "us-west-2"))
.build();

DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("Movies");

ScanSpec scanSpec = new ScanSpec().withProjectionExpression("#yr, title,


info.rating")
.withFilterExpression("#yr between :start_yr and :end_yr").withNameMap(new
NameMap().with("#yr", "year"))
.withValueMap(new ValueMap().withNumber(":start_yr",
1950).withNumber(":end_yr", 1959));

try {
ItemCollection<ScanOutcome> items = table.scan(scanSpec);

Versión de API 2012-08-10


99
Amazon DynamoDB Guía para desarrolladores
Paso 5: (Opcional) Eliminar la tabla

Iterator<Item> iter = items.iterator();


while (iter.hasNext()) {
Item item = iter.next();
System.out.println(item.toString());
}

}
catch (Exception e) {
System.err.println("Unable to scan the table:");
System.err.println(e.getMessage());
}
}
}

En el código, observe lo siguiente:

• ProjectionExpression especifica los atributos que se desea obtener en el resultado del


examen.
• FilterExpression especifica una condición que devuelve solamente los elementos que cumplen
la condición. Todos los demás elementos se descartan.
2. Compile y ejecute el programa.

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

Paso 5: (Opcional) Eliminar la tabla


Para eliminar la tabla Movies:

1. Copie el siguiente programa y péguelo en su entorno de desarrollo de 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.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;

public class MoviesDeleteTable {

Versión de API 2012-08-10


100
Amazon DynamoDB Guía para desarrolladores
Summary

public static void main(String[] args) throws Exception {

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()


.withEndpointConfiguration(new
AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "us-west-2"))
.build();

DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("Movies");

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

2. Compile y ejecute el programa.

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.

Modificación del código para utilizar el servicio de DynamoDB


Debe cambiar el punto de enlace en la aplicación para usar el servicio de DynamoDB.

1. Elimine la importación siguiente.

import com.amazonaws.client.builder.AwsClientBuilder;

2. A continuación, vaya a AmazonDynamoDB en el código.

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.

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()


.withRegion(Regions.REGION)
.build();

Por ejemplo, si desea obtener acceso a la us-west-2 region, tendría que hacer lo siguiente.

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()

Versión de API 2012-08-10


101
Amazon DynamoDB Guía para desarrolladores
JavaScript y DynamoDB

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

Introducción a JavaScript y DynamoDB


En este tutorial, utilizaremos JavaScript para 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 JavaScriptReferencia de la API.

Requisitos previos del tutorial


• Descargue y ejecute DynamoDB en el equipo. 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 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.

Para habilitar CORS

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

Versión de API 2012-08-10


102
Amazon DynamoDB Guía para desarrolladores
Paso 1: Crear una tabla

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:

1. Descargue el siguiente archivo: MoviesJavaScript.zip.


2. Extraiga el archivo MoviesJavaScript.html del archivo comprimido.
3. Modifique el archivo MoviesJavaScript.html para que utilice su punto de enlace.
4. Ejecute el archivo MoviesJavaScript.html.

Paso 1: Creación de una tabla DynamoDB con


JavaScript
En este paso, se crea una tabla denominada Movies. La clave principal de la tabla se compone de los
siguientes atributos:

• year: clave de partición. El valor de AttributeType es N si es numérico.


• title: clave de ordenación. El valor de AttributeType es S si es de cadena.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesCreateTable.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/

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

Versión de API 2012-08-10


103
Amazon DynamoDB Guía para desarrolladores
Paso 1: Crear una tabla

secretAccessKey: "fakeSecretAccessKey"
});

var dynamodb = new AWS.DynamoDB();

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
}
};

dynamodb.createTable(params, function(err, data) {


if (err) {
document.getElementById('textarea').innerHTML = "Unable to create table: "
+ "\n" + JSON.stringify(err, undefined, 2);
} else {
document.getElementById('textarea').innerHTML = "Created table: " + "\n" +
JSON.stringify(data, undefined, 2);
}
});
}

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

Versión de API 2012-08-10


104
Amazon DynamoDB Guía para desarrolladores
Paso 2: Carga de ejemplos de datos

Paso 2: Cargue datos de ejemplo con JavaScript en


DynamoDB
En este paso, se rellena la tabla Movies con ejemplos de datos.

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" : { ... }
},

...

En los datos de JSON, tenga en cuenta lo siguiente:

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

A continuación, se muestra un ejemplo de datos de películas.

{
"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,

Versión de API 2012-08-10


105
Amazon DynamoDB Guía para desarrolladores
Paso 2: Carga de ejemplos de datos

"actors" : [
"David Matthewman",
"Ann Thomas",
"Jonathan G. Neff"
]
}
}

Paso 2.1: Descargue el archivo


1. Descargue el archivo de datos de ejemplo: moviedata.zip
2. Extraiga el archivo de datos (moviedata.json) del archivo comprimido.
3. Copie y pegue el archivo moviedata.json en el directorio actual.

Paso 2.2: Cargue los ejemplos de datos en la tabla Movies


Después de descargar los datos de ejemplo, puede ejecutar el programa siguiente para rellenar la tabla
Movies.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesLoadData.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/

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.
-->
<html>
<head>
<script src="https://sdk.amazonaws.com/js/aws-sdk-2.7.16.min.js"></script>

<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"
});

var docClient = new AWS.DynamoDB.DocumentClient();

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

Versión de API 2012-08-10


106
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización y

var r = new FileReader();


r.onload = function(e) {
var contents = e.target.result;
var allMovies = JSON.parse(contents);

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>

2. Abra el archivo MoviesLoadData.html en el navegador.


3. Elija Browse (Examinar) y cargue el archivo moviedata.json.

Paso 3: Creación, lectura, actualización y


En este paso, se llevan a cabo operaciones de lectura y escritura con un elemento de la tabla Movies.

Para obtener más información sobre cómo leer y escribir datos, consulte Uso de elementos y
atributos (p. 410).

Temas

Versión de API 2012-08-10


107
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización y

• Paso 3.1: Creación de un elemento nuevo (p. 108)


• Paso 3.2: Leer un elemento (p. 109)
• Paso 3.3: Actualización de un elemento (p. 110)
• Paso 3.4: Incremento de un contador atómico (p. 112)
• Paso 3.5: Actualización de un elemento (condicionalmente) (p. 114)
• Paso 3.6: Eliminación de un elemento (p. 116)

Paso 3.1: Creación de un elemento nuevo


En este paso, agregamos un elemento nuevo a la tabla Movies.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps01.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/

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.
-->
<html>
<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"
});

var docClient = new AWS.DynamoDB.DocumentClient();

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

Versión de API 2012-08-10


108
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización y

document.getElementById('textarea').innerHTML = "Unable to add item: " +


"\n" + JSON.stringify(err, undefined, 2);
} else {
document.getElementById('textarea').innerHTML = "PutItem succeeded: " +
"\n" + JSON.stringify(data, undefined, 2);
}
});
}

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

Paso 3.2: Leer un elemento


En el programa anterior, hemos agregado el elemento siguiente a la tabla.

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

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps02.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/

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

Versión de API 2012-08-10


109
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización y

<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"
});

var docClient = new AWS.DynamoDB.DocumentClient();

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>

2. Abra el archivo MoviesItemOps02.html en el navegador.


3. Elija Read Item (Leer elemento).

Paso 3.3: Actualización de un elemento


Puede utilizar el método update para modificar un elemento. Puede actualizar los valores de los atributos
existentes, así como agregar atributos nuevos o eliminarlos.

En este ejemplo, se llevan a cabo las siguientes actualizaciones:

Versión de API 2012-08-10


110
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización y

• Cambie el valor de los atributos existentes (rating, plot).


• Agregue un nuevo atributo de lista (actors) al mapa info existente.

El elemento cambia de lo siguiente:

{
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"]
}
}

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps03.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/

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.
-->
<html>
<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"
});

var docClient = new AWS.DynamoDB.DocumentClient();

Versión de API 2012-08-10


111
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización y

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"
};

docClient.update(params, function(err, data) {


if (err) {
document.getElementById('textarea').innerHTML = "Unable to update item: " +
"\n" + JSON.stringify(err, undefined, 2);
} else {
document.getElementById('textarea').innerHTML = "UpdateItem succeeded: " +
"\n" + JSON.stringify(data, undefined, 2);
}
});
}

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

Paso 3.4: Incremento de un contador atómico


DynamoDB admite contadores atómicos, en los que se utiliza la funciónupdateUtilice el método para
aumentar o reducir el valor de un atributo sin interferir con otras solicitudes de escritura. Todas las
solicitudes de escritura se aplican en el orden en que se reciben.

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.

Versión de API 2012-08-10


112
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización y

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps04.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/

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.
-->
<html>
<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"
});

var docClient = new AWS.DynamoDB.DocumentClient();

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"
};

docClient.update(params, function(err, data) {


if (err) {
document.getElementById('textarea').innerHTML = "Unable to update rating: "
+ "\n" + JSON.stringify(err, undefined, 2);
} else {
document.getElementById('textarea').innerHTML = "Increase Rating succeeded:
" + "\n" + JSON.stringify(data, undefined, 2);
}
});
}

Versión de API 2012-08-10


113
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización y

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

2. Abra el archivo MoviesItemOps04.html en el navegador.


3. Elija Increase Rating (Aumentar valoración).

Paso 3.5: Actualización de un elemento (condicionalmente)


El programa siguiente muestra cómo usar UpdateItem con una condición. Si la condición se evalúa en
true (verdadero), la actualización se lleva a cabo correctamente; de lo contrario, la actualización no se
realiza.

En este caso, el elemento se actualiza solamente si hay más de tres actores en la película.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps05.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/

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.
-->
<html>
<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"
});

var docClient = new AWS.DynamoDB.DocumentClient();

function conditionalUpdate() {
var table = "Movies";
var year = 2015;

Versión de API 2012-08-10


114
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización y

var title = "The Big New Movie";

// Conditional update (will fail)


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"
};

docClient.update(params, function(err, data) {


if (err) {
document.getElementById('textarea').innerHTML = "The conditional update
failed: " + "\n" + JSON.stringify(err, undefined, 2);
} else {
document.getElementById('textarea').innerHTML = "The conditional update
succeeded: " + "\n" + JSON.stringify(data, undefined, 2);
}
});
}

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

2. Abra el archivo MoviesItemOps05.html en el navegador.


3. Elija Conditional Update (Actualización condicional).

Debe producirse un error en el programa y mostrar el mensaje siguiente:

The conditional update failed (Error en la actualización condicional)

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.

ConditionExpression: "size(info.actors) >= :num",

Ahora, la condición es mayor o igual que 3 en lugar de mayor que 3.


5. Ejecute el programa de nuevo. Ahora, la operación updateItem debería realizarse correctamente.

Versión de API 2012-08-10


115
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización y

Paso 3.6: Eliminación de un elemento


Puede utilizar el método delete para eliminar un elemento especificando su clave principal. También
puede incluir una instrucción ConditionExpression para evitar que se elimine el elemento si no se
cumple la condición.

En el siguiente ejemplo, se intenta eliminar un elemento de película determinado si su calificación es igual


o menor que 5.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps06.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/

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.
-->
<html>
<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"
});

var docClient = new AWS.DynamoDB.DocumentClient();

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
}
};

docClient.delete(params, function(err, data) {


if (err) {

Versión de API 2012-08-10


116
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consultar y examinar los datos

document.getElementById('textarea').innerHTML = "The conditional delete


failed: " + "\n" + JSON.stringify(err, undefined, 2);
} else {
document.getElementById('textarea').innerHTML = "The conditional delete
succeeded: " + "\n" + JSON.stringify(data, undefined, 2);
}
});
}

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

2. Abra el archivo MoviesItemOps06.html en el navegador.


3. Elija Conditional Delete (Eliminación condicional).

Debe producirse un error en el programa y mostrar el mensaje siguiente:

The conditional delete failed (Error en la eliminación condicional)

Esto se debe a que la calificación de esta película concreta es mayor que 5.


4. Modifique el programa para eliminar la condición de params.

var params = {
TableName:table,
Key:{
"title":title,
"year":year
}
};

5. Ejecute el programa de nuevo. La eliminación se llevará a cabo correctamente porque se ha eliminado


la condición.

Paso 4: Consultar y examinar los datos con JavaScript


y DynamoDB
Puede utilizar el método query para recuperar datos de una tabla. Debe especificar un valor de clave de
partición; la clave de ordenación es opcional.

La clave principal de la tabla Movies consta de:

• year: clave de partición. El tipo de atributo es Number. 


• title: clave de ordenación. El tipo de atributo es String.

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

Versión de API 2012-08-10


117
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consultar y examinar los datos

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)

Paso 4.1: Consulta - Todas las películas estrenadas durante un


año
El programa incluido en este paso recupera todas las películas estrenadas en el año (year) 1985.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesQuery01.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/

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.
-->
<html>
<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"
});

var docClient = new AWS.DynamoDB.DocumentClient();

function queryData() {
document.getElementById('textarea').innerHTML += "Querying for movies from 1985.";

var params = {
TableName : "Movies",
KeyConditionExpression: "#yr = :yyyy",
ExpressionAttributeNames:{
"#yr": "year"
},
ExpressionAttributeValues: {

Versión de API 2012-08-10


118
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consultar y examinar los datos

":yyyy":1985
}
};

docClient.query(params, function(err, data) {


if (err) {
document.getElementById('textarea').innerHTML += "Unable to query. Error: "
+ "\n" + JSON.stringify(err, undefined, 2);
} else {
document.getElementById('textarea').innerHTML += "Querying for movies from
1985: " + "\n" + JSON.stringify(data, undefined, 2);
}
});
}

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

ExpressionAttributeNames permite sustituir nombres. Esto se usa porqueyeares


una palabra reservada en Amazon DynamoDB. No puede usarlo directamente en ninguna
expresión, incluida KeyConditionExpression. Por este motivo, se utiliza el nombre de
atributo de expresión #yr.
ExpressionAttributeValues permite sustituir valores. Se utiliza porque no se pueden
utilizar literales en ninguna expresión, incluida KeyConditionExpression. Por este motivo,
se utiliza el valor de atributo de expresión :yyyy.
2. Abra el archivo MoviesQuery01.html en el navegador.
3. Elija Query (Consulta).

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

Paso 4.2: Consulta - Todas las películas estrenadas durante un


año con unos títulos
El programa incluido en este paso recupera todas las películas estrenadas el año (year) 1992, cuyo título
(title) comienza por las letras de la "A" a la "L".

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesQuery02.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

Versión de API 2012-08-10


119
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consultar y examinar los datos

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.
-->
<html>
<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"
});

var docClient = new AWS.DynamoDB.DocumentClient();

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"
}
};

docClient.query(params, function(err, data) {


if (err) {
document.getElementById('textarea').innerHTML += "Unable to query. Error: "
+ "\n" + JSON.stringify(err, undefined, 2);
} else {
document.getElementById('textarea').innerHTML += "Querying for movies
from 1992 - titles A-L, with genres and lead actor: " + "\n" + JSON.stringify(data,
undefined, 2);
}
});
}

</script>
</head>

<body>
<input id="queryData" type="button" value="Query" onclick="queryData();" />
<br><br>
<textarea readonly id= "textarea" style="width:400px; height:800px"></textarea>

Versión de API 2012-08-10


120
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consultar y examinar los datos

</body>
</html>

2. Abra el archivo MoviesQuery02.html en el navegador.


3. Elija Query (Consulta).

Paso 4.3: Examen


El método scan lee cada uno de los elementos de la tabla y devuelve todos los datos de la tabla. Puede
proporcionar una expresión filter_expression opcional para que solamente se devuelvan los
elementos que coinciden con los criterios. No obstante, el filtro solo se aplica después de haber examinado
toda la tabla.

El programa siguiente examina la tabla Movies en su totalidad, que contiene aproximadamente


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

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesScan.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/

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.
-->
<html>
<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"
});

var docClient = new AWS.DynamoDB.DocumentClient();

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",

Versión de API 2012-08-10


121
Amazon DynamoDB Guía para desarrolladores
Paso 5: (Opcional): Eliminar la tabla

},
ExpressionAttributeValues: {
":start_yr": 1950,
":end_yr": 1959
}
};

docClient.scan(params, onScan);

function onScan(err, data) {


if (err) {
document.getElementById('textarea').innerHTML += "Unable to scan the table:
" + "\n" + JSON.stringify(err, undefined, 2);
} else {
// Print all the movies
document.getElementById('textarea').innerHTML += "Scan succeeded. " + "\n";
data.Items.forEach(function(movie) {
document.getElementById('textarea').innerHTML += movie.year + ": " +
movie.title + " - rating: " + movie.info.rating + "\n";
});

// Continue scanning if we have more movies (per scan 1MB limitation)


document.getElementById('textarea').innerHTML += "Scanning for more..." +
"\n";
params.ExclusiveStartKey = data.LastEvaluatedKey;
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>

En el código, observe lo siguiente:

• ProjectionExpression especifica los atributos que se desea obtener en el resultado del


examen.
• FilterExpression especifica una condición que devuelve solamente los elementos que cumplen
la condición. Todos los demás elementos se descartan.
2. Abra el archivo MoviesScan.html en el navegador.
3. Seleccione Scan (Analizar).

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

Paso 5: Eliminar la tabla con JavaScript


Para eliminar la tabla Movies:

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesDeleteTable.html.

Versión de API 2012-08-10


122
Amazon DynamoDB Guía para desarrolladores
Paso 5: (Opcional): Eliminar 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.
-->
<html>
<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"
});

var dynamodb = new AWS.DynamoDB();

function deleteMovies() {
var params = {
TableName : "Movies"
};

dynamodb.deleteTable(params, function(err, data) {


if (err) {
document.getElementById('textarea').innerHTML = "Unable to delete table: "
+ "\n" + JSON.stringify(err, undefined, 2);
} else {
document.getElementById('textarea').innerHTML = "Table deleted.";
}
});
}

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

2. Abra el archivo MoviesDeleteTable.html en el navegador.


3. Elija Delete Table (Eliminar tabla).

Versión de API 2012-08-10


123
Amazon DynamoDB Guía para desarrolladores
Resumen

Tutorial y revisión de JavaScript y DynamoDB


En este tutorial, hemos 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.

Actualización delAWSRegión de configuración para utilizar el


servicio web de DynamoDB
Para usar el servicio web de DynamoDB, debe actualizar elAWSRegión en su solicitud. También debe
asegurarse de que Amazon Cognito esté disponible en la misma región, para que los scripts del navegador
se puedan autenticar correctamente.

AWS.config.update({region: "aws-region"});

Por ejemplo, si desea utilizar la región us-west-2, establezca la región siguiente.

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.

ConfiguraciónAWSCredenciales en sus archivos mediante


Amazon Cognito
La forma recomendada de obtenerAWSLas credenciales de para las aplicaciones web y para móviles son
utilizar Amazon Cognito. Amazon Cognito le ayuda a evitar codificar de forma rígidaAWSen sus archivos.
Amazon Cognito utilizaAWS Identity and Access Management(IAM) con el fin de generar credenciales
temporales para los usuarios autenticados y no autenticados de las aplicaciones.

Para obtener más información, consulte ConfiguraciónAWSCredenciales en sus archivos mediante


Amazon Cognito (p. 1029).

Introducción a Node.js y DynamoDB


En este tutorial, utilizará laAWS SDK for JavaScriptPara escribir aplicaciones sencillas que lleven a cabo
las siguientes operaciones de Amazon DynamoDB:

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

Versión de API 2012-08-10


124
Amazon DynamoDB Guía para desarrolladores
Requisitos previos del tutorial

Requisitos previos del tutorial


• Descargue y ejecute DynamoDB en el equipo. 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 información


sobre cómo ejecutar el mismo código en el servicio web de DynamoDB, consulte
laSummary (p. 141).
• Configurar unaAWSpara usar elAWSSDK de en. Para obtener más información, consulte Configuración
de DynamoDB (servicio web) (p. 57).
• Configurar la AWS SDK for JavaScript:
• Instale Node.js.
• Instale la AWS SDK for JavaScript.

Para obtener más información, consulte la Guía de introducción a AWS SDK for JavaScript.

Paso 1: Crear una tabla con en DynamoDB conAWS


SDK for JavaScript
En este paso, se crea una tabla denominada Movies. La clave principal de la tabla se compone de los
siguientes atributos:

• year: clave de partición. El valor de AttributeType es N si es numérico.


• title: clave de ordenación. El valor de AttributeType es S si es de cadena.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesCreateTable.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.
*/
var AWS = require("aws-sdk");

AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});

var dynamodb = new AWS.DynamoDB();

var params = {
TableName : "Movies",
KeySchema: [
{ AttributeName: "year", KeyType: "HASH"}, //Partition key

Versión de API 2012-08-10


125
Amazon DynamoDB Guía para desarrolladores
Paso 2: Carga de ejemplos de datos

{ AttributeName: "title", KeyType: "RANGE" } //Sort key


],
AttributeDefinitions: [
{ AttributeName: "year", AttributeType: "N" },
{ AttributeName: "title", AttributeType: "S" }
],
ProvisionedThroughput: {
ReadCapacityUnits: 10,
WriteCapacityUnits: 10
}
};

dynamodb.createTable(params, function(err, data) {


if (err) {
console.error("Unable to create table. Error JSON:", JSON.stringify(err, null,
2));
} else {
console.log("Created table. Table description JSON:", JSON.stringify(data,
null, 2));
}
});

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

Paso 2: Cargue datos de ejemplo en DynamoDB


conAWS SDK for JavaScript
En este paso, se rellena la tabla Movies con ejemplos de datos.

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" : ... ,

Versión de API 2012-08-10


126
Amazon DynamoDB Guía para desarrolladores
Paso 2: Carga de ejemplos de datos

"info" : { ... }
},
{
"year" : ...,
"title" : ...,
"info" : { ... }
},

...

En los datos de JSON, tenga en cuenta lo siguiente:

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

A continuación, se muestra un ejemplo de datos de películas.

{
"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"
]
}
}

Paso 2.1: Descargue el ejemplo de datos


1. Descargue el archivo de datos de ejemplo: moviedata.zip
2. Extraiga el archivo de datos (moviedata.json) del archivo comprimido.
3. Copie y pegue el archivo moviedata.json en el directorio actual.

Paso 2.2: Cargue los ejemplos de datos en la tabla Movies


Después de descargar los datos de ejemplo, puede ejecutar el programa siguiente para rellenar la tabla
Movies.

Versión de API 2012-08-10


127
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesLoadData.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.
*/
var AWS = require("aws-sdk");
var fs = require('fs');

AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});

var docClient = new AWS.DynamoDB.DocumentClient();

console.log("Importing movies into DynamoDB. Please wait.");

var allMovies = JSON.parse(fs.readFileSync('moviedata.json', 'utf8'));


allMovies.forEach(function(movie) {
var params = {
TableName: "Movies",
Item: {
"year": movie.year,
"title": movie.title,
"info": movie.info
}
};

docClient.put(params, function(err, data) {


if (err) {
console.error("Unable to add movie", movie.title, ". Error JSON:",
JSON.stringify(err, null, 2));
} else {
console.log("PutItem succeeded:", movie.title);
}
});
});

2. Para ejecutar el programa, introduzca el siguiente comando.

node MoviesLoadData.js

Paso 3: Creación, lectura, actualización y eliminación


de elementos
En este paso, se llevan a cabo operaciones de lectura y escritura con un elemento de la tabla Movies.

Para obtener más información sobre cómo leer y escribir datos, consulte Uso de elementos y
atributos (p. 410).

Versión de API 2012-08-10


128
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

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)

Paso 3.1: Creación de un elemento nuevo


En este paso, agregamos un elemento nuevo a la tabla Movies.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps01.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.
*/
var AWS = require("aws-sdk");

AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});

var docClient = new AWS.DynamoDB.DocumentClient();

var table = "Movies";

var year = 2015;


var title = "The Big New Movie";

var params = {
TableName:table,
Item:{
"year": year,
"title": title,
"info":{
"plot": "Nothing happens at all.",
"rating": 0
}
}
};

console.log("Adding a new item...");


docClient.put(params, function(err, data) {
if (err) {
console.error("Unable to add item. Error JSON:", JSON.stringify(err, null, 2));
} else {
console.log("Added item:", JSON.stringify(data, null, 2));

Versión de API 2012-08-10


129
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

}
});

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

Paso 3.2: Lectura de un elemento


En el programa anterior, hemos agregado el elemento siguiente a la tabla.

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

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps02.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.
*/
var AWS = require("aws-sdk");

AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});

var docClient = new AWS.DynamoDB.DocumentClient();

var table = "Movies";

var year = 2015;


var title = "The Big New Movie";

var params = {
TableName: table,

Versión de API 2012-08-10


130
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

Key:{
"year": year,
"title": title
}
};

docClient.get(params, function(err, data) {


if (err) {
console.error("Unable to read item. Error JSON:", JSON.stringify(err, null,
2));
} else {
console.log("GetItem succeeded:", JSON.stringify(data, null, 2));
}
});

2. Para ejecutar el programa, introduzca el siguiente comando.

node MoviesItemOps02.js

Paso 3.3: Actualización de un elemento


Puede utilizar el método update para modificar un elemento existente. Puede actualizar los valores de los
atributos existentes, así como agregar atributos nuevos o eliminarlos.

En este ejemplo, se llevan a cabo las siguientes actualizaciones:

• Cambie el valor de los atributos existentes (rating, plot).


• Agregue un nuevo atributo de lista (actors) al mapa info existente.

Anteriormente, agregó el siguiente elemento a la tabla.

{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}

El elemento se actualiza como se indica a continuación.

{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Everything happens all at once.",
rating: 5.5,
actors: ["Larry", "Moe", "Curly"]
}
}

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps03.js.

/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*

Versión de API 2012-08-10


131
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

* 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 docClient = new AWS.DynamoDB.DocumentClient()

var table = "Movies";

var year = 2015;


var title = "The Big New Movie";

// Update the item, unconditionally,

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"
};

console.log("Updating the item...");


docClient.update(params, function(err, data) {
if (err) {
console.error("Unable to update item. Error JSON:", JSON.stringify(err, null,
2));
} else {
console.log("UpdateItem succeeded:", JSON.stringify(data, null, 2));
}
});

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

Versión de API 2012-08-10


132
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

Paso 3.4: Incremento de un contador atómico


DynamoDB admite contadores atómicos, donde se utiliza el comandoupdatepara aumentar o reducir el
valor de un atributo sin interferir con otras solicitudes de escritura. Todas las solicitudes de escritura se
aplican en el orden en que se reciben.

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.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps04.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.
*/
var AWS = require("aws-sdk");

AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});

var docClient = new AWS.DynamoDB.DocumentClient()

var table = "Movies";

var year = 2015;


var title = "The Big New Movie";

// Increment an atomic counter

var params = {
TableName:table,
Key:{
"year": year,
"title": title
},
UpdateExpression: "set info.rating = info.rating + :val",
ExpressionAttributeValues:{
":val": 1
},
ReturnValues:"UPDATED_NEW"
};

console.log("Updating the item...");


docClient.update(params, function(err, data) {
if (err) {
console.error("Unable to update item. Error JSON:", JSON.stringify(err, null,
2));
} else {
console.log("UpdateItem succeeded:", JSON.stringify(data, null, 2));
}
});

Versión de API 2012-08-10


133
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

2. Para ejecutar el programa, introduzca el siguiente comando.

node MoviesItemOps04.js

Paso 3.5: Actualización de un elemento (condicionalmente)


El programa siguiente muestra cómo usar UpdateItem con una condición. Si la condición se evalúa en
true (verdadero), la actualización se lleva a cabo correctamente; de lo contrario, la actualización no se
realiza.

En este caso, el elemento se actualiza solamente si hay más de tres actores en la película.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps05.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.
*/
var AWS = require("aws-sdk");

AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});

var docClient = new AWS.DynamoDB.DocumentClient()

var table = "Movies";

var year = 2015;


var title = "The Big New Movie";

// Conditional update (will fail)

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"
};

console.log("Attempting a conditional update...");


docClient.update(params, function(err, data) {
if (err) {
console.error("Unable to update item. Error JSON:", JSON.stringify(err, null,
2));

Versión de API 2012-08-10


134
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

} else {
console.log("UpdateItem succeeded:", JSON.stringify(data, null, 2));
}
});

2. Para ejecutar el programa, introduzca el siguiente comando.

node MoviesItemOps05.js

Debe producirse un error en el programa y mostrar el mensaje siguiente.

The conditional request failed (Error en la solicitud condicional)

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.

ConditionExpression: "size(info.actors) >= :num",

Ahora, la condición es mayor o igual que 3 en lugar de mayor que 3.


4. Ejecute el programa de nuevo. Ahora, la operación updateItem debería realizarse correctamente.

Paso 3.6: Eliminación de un elemento


Puede utilizar el método delete para eliminar un elemento especificando su clave principal. También
puede incluir una instrucción ConditionExpression para evitar que se elimine el elemento si no se
cumple la condición.

En el siguiente ejemplo, se intenta eliminar un elemento de película determinado si su calificación es igual


o menor que 5.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps06.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.
*/
var AWS = require("aws-sdk");

AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});

var docClient = new AWS.DynamoDB.DocumentClient();

var table = "Movies";

var year = 2015;


var title = "The Big New Movie";

Versión de API 2012-08-10


135
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y análisis de datos

var params = {
TableName:table,
Key:{
"year": year,
"title": title
},
ConditionExpression:"info.rating <= :val",
ExpressionAttributeValues: {
":val": 5.0
}
};

console.log("Attempting a conditional delete...");


docClient.delete(params, function(err, data) {
if (err) {
console.error("Unable to delete item. Error JSON:", JSON.stringify(err, null,
2));
} else {
console.log("DeleteItem succeeded:", JSON.stringify(data, null, 2));
}
});

2. Para ejecutar el programa, introduzca el siguiente comando.

node MoviesItemOps06.js

Debe producirse un error en el programa y mostrar el mensaje siguiente.

The conditional request failed (Error en la solicitud condicional)

Esto se debe a que la calificación de esta película concreta es mayor que 5.


3. Modifique el programa para eliminar la condición de params.

var params = {
TableName:table,
Key:{
"title":title,
"year":year
}
};

4. Ejecute el programa de nuevo. Ahora, la eliminación se llevará a cabo correctamente porque se ha


eliminado la condición.

Paso 4: Consulta y análisis de datos conAWS SDK for


JavaScripten DynamoDB
Puede utilizar el método query para recuperar datos de una tabla. Debe especificar un valor de clave de
partición; la clave de ordenación es opcional.

La clave principal de la tabla Movies consta de:

• year: clave de partición. El tipo de atributo es Number. 


• title: clave de ordenación. El tipo de atributo es String.

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

Versión de API 2012-08-10


136
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y análisis de datos

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)

Paso 4.1: Consulta de todas las películas estrenadas durante un


año
El programa incluido en este paso recupera todas las películas estrenadas en el año (year) 1985.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesQuery01.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.
*/
var AWS = require("aws-sdk");

AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});

var docClient = new AWS.DynamoDB.DocumentClient();

console.log("Querying for movies from 1985.");

var params = {
TableName : "Movies",
KeyConditionExpression: "#yr = :yyyy",
ExpressionAttributeNames:{
"#yr": "year"
},
ExpressionAttributeValues: {
":yyyy": 1985
}
};

docClient.query(params, function(err, data) {


if (err) {

Versión de API 2012-08-10


137
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y análisis de datos

console.error("Unable to query. Error:", JSON.stringify(err, null, 2));


} else {
console.log("Query succeeded.");
data.Items.forEach(function(item) {
console.log(" -", item.year + ": " + item.title);
});
}
});

Note

ExpressionAttributeNames permite sustituir nombres. Usa esto 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.
ExpressionAttributeValues permite sustituir valores. Se utiliza porque no se pueden
utilizar literales en ninguna una expresión, lo que incluye KeyConditionExpression. Para
solucionar este problema se utiliza el valor de atributo de expresión :yyyy.
2. Para ejecutar el programa, introduzca el siguiente comando.

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

Paso 4.2: Consulta de todas las películas estrenadas durante un


año con unos títulos determinados
El programa incluido en este paso recupera todas las películas estrenadas el año (year) 1992, cuyo título
(title) comienza por las letras de la "A" a la "L".

1. Copie el siguiente programa y péguelo en un archivo llamado 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
* 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"
});

Versión de API 2012-08-10


138
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y análisis de datos

var docClient = new AWS.DynamoDB.DocumentClient();

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"
}
};

docClient.query(params, function(err, data) {


if (err) {
console.log("Unable to query. Error:", JSON.stringify(err, null, 2));
} else {
console.log("Query succeeded.");
data.Items.forEach(function(item) {
console.log(" -", item.year + ": " + item.title
+ " ... " + item.info.genres
+ " ... " + item.info.actors[0]);
});
}
});

2. Para ejecutar el programa, introduzca el siguiente comando.

node MoviesQuery02.js

Paso 4.3: Examen


El método scan lee cada uno de los elementos de la tabla y devuelve todos los datos de la tabla. Puede
proporcionar una expresión filter_expression opcional para que solamente se devuelvan los
elementos que coinciden con los criterios. No obstante, el filtro solo se aplica después de haber examinado
toda la tabla.

El programa siguiente examina la tabla Movies en su totalidad, que contiene aproximadamente


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

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesScan.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

Versión de API 2012-08-10


139
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y análisis de datos

* 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 docClient = new AWS.DynamoDB.DocumentClient();

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
}
};

console.log("Scanning Movies table.");


docClient.scan(params, onScan);

function onScan(err, data) {


if (err) {
console.error("Unable to scan the table. Error JSON:", JSON.stringify(err,
null, 2));
} else {
// print all the movies
console.log("Scan succeeded.");
data.Items.forEach(function(movie) {
console.log(
movie.year + ": ",
movie.title, "- rating:", movie.info.rating);
});

// continue scanning if we have more movies, because


// scan can retrieve a maximum of 1MB of data
if (typeof data.LastEvaluatedKey != "undefined") {
console.log("Scanning for more...");
params.ExclusiveStartKey = data.LastEvaluatedKey;
docClient.scan(params, onScan);
}
}
}

En el código, observe lo siguiente:

• ProjectionExpression especifica los atributos que se desea obtener en el resultado del


examen.
• FilterExpression especifica una condición que devuelve solamente los elementos que cumplen
la condición. Todos los demás elementos se descartan.
2. Para ejecutar el programa, introduzca el siguiente comando.

node MoviesScan.js

Versión de API 2012-08-10


140
Amazon DynamoDB Guía para desarrolladores
Paso 5: (Opcional): Eliminar la tabla

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

Paso 5: (Opcional): Elimine la tabla usandoAWS SDK


for JavaScript
Para eliminar la tabla Movies:

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesDeleteTable.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.
*/
var AWS = require("aws-sdk");

AWS.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
});

var dynamodb = new AWS.DynamoDB();

var params = {
TableName : "Movies"
};

dynamodb.deleteTable(params, function(err, data) {


if (err) {
console.error("Unable to delete table. Error JSON:", JSON.stringify(err, null,
2));
} else {
console.log("Deleted table. Table description JSON:", JSON.stringify(data,
null, 2));
}
});

2. Para ejecutar el programa, introduzca el siguiente comando.

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

Versión de API 2012-08-10


141
Amazon DynamoDB Guía para desarrolladores
.NET y DynamoDB

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.

Modificación del código para utilizar el servicio de DynamoDB


Debe cambiar el punto de enlace en la aplicación para usar el servicio de DynamoDB de. Para ello,
modifique el siguiente código.

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.

Introducción a .NET y DynamoDB


En este tutorial, utilizará laAWS SDK for .NETPara escribir programas sencillos que lleven a cabo las
operaciones de Amazon DynamoDB siguientes:

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

Versión de API 2012-08-10


142
Amazon DynamoDB Guía para desarrolladores
Requisitos previos del tutorial

• Paso 7: Eliminar condicionalmente (p. 154)


• Paso 8: Consultar una tabla de DynamoDB con .NET (p. 155)
• Paso 9: Analizar la tabla Movies con .NET (p. 157)
• Paso 10: Eliminación de la tabla Movies con .NET (p. 159)

Requisitos previos del tutorial de.NET y DynamoDB


LaTutorial de Microsoft NET y DynamoDB (p. 142)Se describe cómo utilizar elAWS SDK for .NETpara
crear programas sencillos para realizar operaciones de Amazon DynamoDB.

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:

1. Descargue un archivo.zip que contenga la solución deDynamoDB_intro.zip.


2. Guarde el archivo en un lugar conveniente en su computadora y extraiga (descomprima) los
archivos que contiene.
3. En Visual Studio, presioneCtrl+Mayús+O, o elijaOpenen elArchivoy elijaProyecto/Solución.
4. Vaya aDynamoDB_intro.slnen laDynamoDB_introque descomprimió y elijaOpen.
• Cree elDynamoDB_introy, a continuación, abra el00_Main.csen Visual Studio.

1. En la páginaBuildEn el menú, elijaBuild Solution(o pulseCtrl+Shift+B). La solución debe


compilarse correctamente.
2. Asegúrese de que elExplorador de solucionesse está mostrando y anclando en Visual Studio. En
caso de que no, puede encontrarlo en laVista, o presionandoCtrl+Alt+L.
3. EnExplorador de soluciones, abra el00_Main.csfile. Este es el archivo que controla la ejecución del
programa de demostración que se utiliza en este tutorial.

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.

Versión de API 2012-08-10


143
Amazon DynamoDB Guía para desarrolladores
Paso 1: Creación de un cliente

Instalación de las dependencias externas de la solución


DynamoDB_INTRO
LaDynamoDB_introya tiene instalado el SDK de Amazon DynamoDB. También cuenta con el Newtonsoft
de código abiertoJson.NETPara deserializar los datos de JSON, bajo licencia del MIT (consulte).https://
github.com/JamesNK/Newtonsoft.Json/blob/master/LICENSE.md).

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)

Paso 1: Creación de un cliente de DynamoDB


El primer paso en elTutorial de Microsoft NET y DynamoDB (p. 142)es crear un cliente que le
proporcione acceso a la API de Amazon DynamoDB. La función Main en DynamoDB_intro lo hace
llamando a una función createClient implementada en el archivo 01_CreateClient.cs.

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.

*-----------------------------------------------------------------------------------*/

Versión de API 2012-08-10


144
Amazon DynamoDB Guía para desarrolladores
Paso 1: Creación de un cliente

// So we know whether local DynamoDB is running


private static readonly string Ip = "localhost";
private static readonly int Port = 8000;
private static readonly string EndpointUrl = "http://" + Ip + ":" + Port;
private static bool IsPortInUse()
{
bool isAvailable = true;
// Evaluate current system TCP connections. This is the same information
provided
// by the netstat command line application, just in .Net strongly-typed object
// form. We will look through the list, and if our port we would like to use
// in our TcpClient is occupied, we will set isAvailable to false.
IPGlobalProperties ipGlobalProperties =
IPGlobalProperties.GetIPGlobalProperties();
IPEndPoint[] tcpConnInfoArray = ipGlobalProperties.GetActiveTcpListeners();
foreach (IPEndPoint endpoint in tcpConnInfoArray)
{
if (endpoint.Port == Port)
{
isAvailable = false;
break;
}
}

return isAvailable;
}

public static bool createClient(bool useDynamoDbLocal)


{
if (useDynamoDbLocal)
{
// First, check to see whether anyone is listening on the DynamoDB local
port
// (by default, this is port 8000, so if you are using a different port,
modify this accordingly)
var portUsed = IsPortInUse();
if (portUsed)
{
Console.WriteLine("The local version of DynamoDB is NOT running.");
return (false);
}

// DynamoDB-Local is running, so create a client


Console.WriteLine(" -- Setting up a DynamoDB-Local client (DynamoDB Local
seems to be running)");
AmazonDynamoDBConfig ddbConfig = new AmazonDynamoDBConfig();
ddbConfig.ServiceURL = EndpointUrl;
try
{
Client = new AmazonDynamoDBClient(ddbConfig);
}
catch (Exception ex)
{
Console.WriteLine(" FAILED to create a DynamoDBLocal client; " +
ex.Message);
return false;
}
}
else
{
Client = new AmazonDynamoDBClient();
}

return true;
}
}

Versión de API 2012-08-10


145
Amazon DynamoDB Guía para desarrolladores
Paso 2: Crear una tabla

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

Configuración de lauseDynamoDBLocalparámetro parafalseCrea un cliente para el propio servicio de


DynamoDB en lugar del programa de prueba local.

Paso siguiente
Paso 2: Creación de una tabla de DynamoDB con la API de bajo nivel (p. 146)

Paso 2: Creación de una tabla de DynamoDB con la


API de bajo nivel
El modelo de documento del AWS SDK for .NET no se proporciona para la creación de tablas, por lo que
tendrá que utilizar API de bajo nivel. Para obtener más información, consulte Uso de tablas de DynamoDB
en .NET (p. 403).

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:

• year: clave de partición. El valor de AttributeType es N si es numérico.


Note

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.

La función Main en DynamoDB_intro lo hace llamando a una función asíncrona


CreatingTable_async, que está implementada en el archivo 02_CreatingTable.cs.

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

public static async Task<bool> CreateTable_async(string tableName,


List<AttributeDefinition> tableAttributes,
List<KeySchemaElement> tableKeySchema,
ProvisionedThroughput provisionedThroughput)
{

Versión de API 2012-08-10


146
Amazon DynamoDB Guía para desarrolladores
Paso 2: Crear una tabla

bool response = true;

// Build the 'CreateTableRequest' structure for the new table


var request = new CreateTableRequest
{
TableName = tableName,
AttributeDefinitions = tableAttributes,
KeySchema = tableKeySchema,
// Provisioned-throughput settings are always required,
// although the local test version of DynamoDB ignores them.
ProvisionedThroughput = provisionedThroughput
};

try
{
var makeTbl = await DdbIntro.Client.CreateTableAsync(request);
}
catch (Exception)
{
response = false;
}

return response;
}

public static async Task<TableDescription> GetTableDescription(string tableName)


{
TableDescription result = null;

// If the table exists, get its description.


try
{
var response = await DdbIntro.Client.DescribeTableAsync(tableName);
result = response.Table;
}
catch (Exception)
{}

return result;
}
}
}

La función CreatingTable_async comienza esperando en una función asíncrona


checkingTableExistence_async para determinar si ya existe una tabla denominada "Movies". Si
la tabla existe, checkingTableExistence_async recupera la TableDescription para la Table
existente.

Si la tabla no existe todavía,CreatingTable_asyncespera enCreateNewTable_asyncPara crear


elMoviescon la API de cliente de DynamoDBCreateTableAsync.

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)

Versión de API 2012-08-10


147
Amazon DynamoDB Guía para desarrolladores
Paso 3: Carga de datos

Paso 3: Carga de datos de ejemplo en la tabla de


DynamoDB
En este paso de laTutorial de Microsoft NET y DynamoDB (p. 142), rellena el nuevoMoviesEn Amazon
DynamoDB con datos de ejemplo de Internet Movie Database (IMDb). Estos datos están almacenados en
formato JSON en un archivo de texto local denominado moviedata.json.

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

Antes de cargar el archivo moviedata.json, la función Main en DynamoDB_intro realiza


comprobaciones para determinar si la tabla Movies existe y todavía está vacía. En tal caso, espera en una
función LoadingData_async asíncrona que está implementada en el archivo 03_LoadingData.cs.

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;

Versión de API 2012-08-10


148
Amazon DynamoDB Guía para desarrolladores
Paso 3: Carga de datos

public static async Task<JArray> ReadJsonMovieFile_async(string jsonMovieFilePath)


{
StreamReader sr = null;
JsonTextReader jtr = null;
JArray movieArray = null;

Console.WriteLine(" -- Reading the movies data from a JSON file...");

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;
}

public static async Task<bool> LoadJsonMovieData_async(Table moviesTable, JArray


moviesArray)
{
int n = moviesArray.Count;
Console.Write(" -- Starting to load {0:#,##0} movie records into the Movies
table asynchronously...\n" + "" +
" Wrote: ", n);
for (int i = 0, j = 99; i < n; i++)
{
try
{
string itemJson = moviesArray[i].ToString();
Document doc = Document.FromJson(itemJson);
Task putItem = moviesTable.PutItemAsync(doc);
if (i >= j)
{
j++;
Console.Write("{0,5:#,##0}, ", j);
if (j % 1000 == 0)
Console.Write("\n ");
j += 99;
}
await putItem;
}
catch (Exception)
{
return false;
}
}

return true;
}
}
}

Versión de API 2012-08-10


149
Amazon DynamoDB Guía para desarrolladores
Paso 4: Agregar una película

LoadingData_async espera empezando en ReadJsonMovieFile_async. Esta función lee el archivo


moviedata.json utilizando la biblioteca Newtonsoft Json.NET de código abierto, que se encuentra bajo
la Licencia MIT.

Cuando los datos se han leído correctamente,LoadingData_asyncespera


enLoadJsonMovieData_asyncpara cargar los registros de película en elMoviescon el modelo de
documento de DynamoDBTable.PutItemAsyncAPI. Para obtener información acerca de la API del
modelo de documento, consulte .NET: Modelo de documento (p. 279).

Paso siguiente
Paso 4: Agregar una película a la tabla de DynamoDB (p. 150)

Paso 4: Agregar una película a la tabla de DynamoDB


En este paso de laTutorial de Microsoft NET y DynamoDB (p. 142), agregue un nuevo registro de
película a laMoviesEn Amazon DynamoDB. LaMainfunción enDynamoDB_introcomienza creando
un modelo de documento de DynamoDBDocumenty luego esperaWritingNewMovie_async, que se
implementa en04_WritingNewItem.csfile.

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"];

var response = await ReadingMovie_async(year, name);

return response.Count > 0;


}

public static async Task<bool> WritingNewMovie_async(Document newItem)


{
var result = false;

try
{
var writeNew = await MoviesTable.PutItemAsync(newItem);
Console.WriteLine(" -- Writing a new movie to the Movies table...");

Console.WriteLine(" -- Wrote the item successfully!");


result = true;
}
catch (Exception ex)
{
Console.WriteLine(" FAILED to write the new movie, because:\n
{0}.", ex.Message);
}

return result;
}
}
}

Versión de API 2012-08-10


150
Amazon DynamoDB Guía para desarrolladores
Paso 5: Leer una película

WritingNewMovie_async comienza realizando una comprobación para determinar si la nueva película


ya se ha añadido a la tabla Movies. En caso de que no, espera DynamoDBTable.PutItemAsynPara
agregar el nuevo registro de película.

Para obtener más información


• Para obtener más información sobre cómo leer y escribir datos en tablas de DynamoDB, consulte.Uso
de elementos y atributos (p. 410).
• Para obtener más información sobre la API del modelo de documento de DynamoDB, consulte..NET:
Modelo de documento (p. 279).
• Para obtener más información sobre métodos asíncronos, consulte.AWSAPI asincrónicas de para .NET.

Paso siguiente
Paso 5: Leer y mostrar un registro de la tabla de DynamoDB (p. 151)

Paso 5: Leer y mostrar un registro de la tabla de


DynamoDB
En este paso de laTutorial de Microsoft NET y DynamoDB (p. 142), recupera y muestra el nuevo registro
de película que agregó enPaso 4 (p. 150). La función Main en DynamoDB_intro lo hace llamando a
ReadingMovie_async, que está implementada en el archivo 05_ReadingItem.cs.

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;
}
}
}
}

ReadingMovie_asynca su vez espera en el DynamoDBTable.GetItemAsynpara recuperar el nuevo


registro de película comoDocument.ReadingMovie_asyncluego muestra la película como texto JSON
usando la herramientaDocument.ToJsonPrettyMétodo de.

Versión de API 2012-08-10


151
Amazon DynamoDB Guía para desarrolladores
Paso 6: Actualización de la película

Para obtener más información


• Para obtener más información sobre cómo leer y escribir datos en tablas de DynamoDB, consulte.Uso
de elementos y atributos (p. 410).
• Para obtener más información sobre la API del modelo de documento de DynamoDB, consulte..NET:
Modelo de documento (p. 279).
• Para obtener más información sobre métodos asíncronos, consulte.AWSAPI asincrónicas de para .NET.

Paso siguiente
Paso 6: Actualización del nuevo registro de película en la tabla de DynamoDB (p. 152)

Paso 6: Actualización del nuevo registro de película en


la tabla de DynamoDB
En este paso de laTutorial de Microsoft NET y DynamoDB (p. 142), actualizará el nuevo registro de
película de varias formas distintas.

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)

Cambiar trama y valoración y añadir actores


La función Main en DynamoDB_intro cambia la trama y la valoración del registro de película que añadió
en el Paso 4 (p. 150) y, además, añade una lista de actores al mismo. El modelo de documento en AWS
SDK for .NET no admite la actualización de atributos anidados tales como los elementos en el atributo
info. Por ello, Main utiliza la API de cliente de bajo nivel en lugar de un método Table de modelo de
documento.

Empieza creando un UpdateItemRequest de bajo nivel para realizar este cambio.

UpdateItemRequest updateRequest = new UpdateItemRequest()


{
TableName = movies_table_name,
Key = new Dictionary<string, AttributeValue>
{
{ partition_key_name, new AttributeValue { N = "2018" } },
{ sort_key_name, new AttributeValue { S = "The Big New Movie" } }
},
ExpressionAttributeValues = new Dictionary<string, AttributeValue>
{
{ ":r", new AttributeValue { N = "5.5" } },
{ ":p", new AttributeValue { S = "Everything happens all at once!" } },
{ ":a", new AttributeValue { L = new List<AttributeValue>
{ new AttributeValue { S ="Larry" },
new AttributeValue { S = "Moe" },
new AttributeValue { S = "Curly" } }
}
}

Versión de API 2012-08-10


152
Amazon DynamoDB Guía para desarrolladores
Paso 6: Actualización de la película

},
UpdateExpression = "SET info.rating = :r, info.plot = :p, info.actors = :a",
ReturnValues = "NONE"
};

Al configurar ReturnValues en NONE se especifica que no se debe devolver ninguna información de


actualización. Sin embargo, cuando Main espera a continuación en UpdatingMovie_async, establece
el parámetro informe en true. Esto provoca que UpdatingMovie_async cambie ReturnValues a
ALL_NEW, lo que significa que el elemento actualizado se debe devolver por completo.

El UpdatingMovie_async se implementa en el archivo 06_UpdatingItem.cs.

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;
}
}
}

UpdatingMovie_asyncespera en el DynamoDB de bajo nivelClient.UpdateItemAsyncPara


actualizar el registro de película. Si la actualización se realiza correctamente y si el parámetro informe es
true, UpdatingMovie_async muestra el registro de película actualizado.

Cuando el modelo de documento tiene un método Document.ToJsonPretty( ) práctico para mostrar


contenido de documento, trabajar con valores de atributo de bajo nivel es un poco más complicado. El
archivo 00b_DDB_Attributes.cs puede proporcionar algunos ejemplos de cómo acceder y trabajar con
objetos AttributeValue.

Aumentar la valoración de la película de forma atómica


DynamoDB admite la actualización atómica de contadores, donde se utiliza un método de actualización de
bajo nivel para aumentar o disminuir el valor de un atributo existente sin interferencia de otras solicitudes
de escritura. (Todas las solicitudes de escritura de DynamoDB se aplican en el orden en que se reciben).

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.ExpressionAttributeValues = new Dictionary<string, AttributeValue>


{
{ ":inc", new AttributeValue { N = "1" } }

Versión de API 2012-08-10


153
Amazon DynamoDB Guía para desarrolladores
Paso 7: Eliminación de un elemento con condiciones

};
updateRequest.UpdateExpression = "SET info.rating = info.rating + :inc";

Nuevamente, espera en UpdatingMovie_async para realizar el cambio.

Intentar actualizar utilizando una condición que falla


También puede añadir una condición a una solicitud de actualización, de modo que si la condición no se
cumple, la actualización no se produce.

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.

updateRequest.ExpressionAttributeValues.Add( ":n", new AttributeValue { N = "3" } );


updateRequest.ConditionExpression = "size(info.actors) > :n";

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.

Para obtener más información


• Para obtener más información sobre cómo leer y escribir datos en tablas de DynamoDB, consulte.Uso
de elementos y atributos (p. 410).
• Para obtener más información sobre la API del modelo de documento de DynamoDB, consulte..NET:
Modelo de documento (p. 279).
• Para obtener más información sobre métodos asíncronos, consulte.AWSAPI asincrónicas de para .NET.

Paso siguiente
Paso 7: Eliminar condicionalmente (p. 154)

Paso 7: Eliminar condicionalmente


En este paso de laTutorial de Microsoft NET y DynamoDB (p. 142), intenta eliminar un registro de
película con una condición que no se cumple y la eliminación falla. A continuación, cuando la condición
cambia para que se cumpla, la eliminación se realiza correctamente.

La función Main en DynamoDB_intro comienza creando una condición del siguiente modo.

Expression condition = new Expression();


condition.ExpressionAttributeValues[":val"] = 5.0;
condition.ExpressionStatement = "info.rating <= :val";

La función Main pasa a continuación Expression como uno de los parámetros de


DeletingItem_async y espera. DeletingItem_async se implementa en el archivo
07_DeletingItem.cs.

using System;
using System.Threading.Tasks;
using Amazon.DynamoDBv2.DocumentModel;

namespace DynamoDB_intro
{

Versión de API 2012-08-10


154
Amazon DynamoDB Guía para desarrolladores
Paso 8: Consulta una tabla

public static partial class DdbIntro


{
public static async Task<bool> DeletingItem_async( Table table, int year, string title,
Expression condition=null )
{
Document deletedItem;
// 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);
DeleteItemOperationConfig deleteConfig = new DeleteItemOperationConfig( );
deleteConfig.ConditionalExpression = condition;
deleteConfig.ReturnValues = ReturnValues.AllOldAttributes;

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;
}
}
}

DeletingItem_asyncA su vez incluye la condiciónExpressionen


unDeleteItemOperationConfigque pasa al objeto DynamoDBTable.DeleteItemAsynccuando
espera en él.

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)

Paso 8: Consultar una tabla de DynamoDB con .NET


En este paso de laTutorial de Microsoft NET y DynamoDB (p. 142), consulta elMoviesmesa de tres
formas diferentes.

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)

Versión de API 2012-08-10


155
Amazon DynamoDB Guía para desarrolladores
Paso 8: Consulta una tabla

Utilice una búsqueda de modelo de documento sencilla para


consultar películas de 1985
Para configurar una consulta de modelo de documento sencilla, la función Main en DynamoDB_intro
crea un objeto Search llamando a la API Table.Query con 1985 como clave de partición (también
conocida como clave hash) y un filtro Expression vacío.

try { search = moviesTable.Query( 1985, new Expression( ) ); }

A continuación espera en SearchListing_async, que se implementa en 08_Querying.cs para


recuperar y mostrar los resultados de la consulta.

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;
}

public static async Task<QueryResponse> ClientQuerying_async(QueryRequest qRequest)


{
var response = await Client.QueryAsync(qRequest);
return response;
}
}
}

Utilizar una QueryOperationConfig para crear una búsqueda de


consulta más compleja
Para consulta películas de 1992 con títulos desde "B..." hasta "Hzz...", la función Main crea un objeto
QueryOperationConfig con un QueryFilter y otros campos diversos.

QueryOperationConfig config = new QueryOperationConfig( );


config.Filter = new QueryFilter( );

Versión de API 2012-08-10


156
Amazon DynamoDB Guía para desarrolladores
Paso 9: Examen de una tabla

config.Filter.AddCondition( "year", QueryOperator.Equal, new DynamoDBEntry[ ]


{ 1992 } );
config.Filter.AddCondition( "title", QueryOperator.Between, new DynamoDBEntry[ ]
{ "B", "Hzz" } );
config.AttributesToGet = new List<string> { "year", "title", "info" };
config.Select = SelectValues.SpecificAttributes;

Nuevamente, crea un objeto Search llamando a la API Table.Query, esta vez con el objeto
QueryOperationConfig como único parámetro.

Y de nuevo, espera en SearchListing_async para recuperar y mostrar los resultados de la consulta.

Utilizar una consulta de bajo nivel para buscar películas de 1992


con títulos entre "M..." y "Tzz..."
Para utilizar una consulta de bajo nivel para recuperar películas de 1992 con títulos de "M..." a "Tzz...", la
función Main crea un objeto QueryRequest.

QueryRequest qRequest= new QueryRequest


{
TableName = "Movies",
ExpressionAttributeNames = new Dictionary<string, string>
{
{ "#yr", "year" }
},
ExpressionAttributeValues = new Dictionary<string, AttributeValue>
{
{ ":qYr", new AttributeValue { N = "1992" } },
{ ":tSt", new AttributeValue { S = "M" } },
{ ":tEn", new AttributeValue { S = "Tzz" } }
},
KeyConditionExpression = "#yr = :qYr and title between :tSt and :tEn",
ProjectionExpression = "#yr, title, info.actors[0], info.genres,
info.running_time_secs"
};

A continuación, espera en elClientQuerying_asyncimplementada en


el08_Querying.csfile.ClientQuerying_asyncespera a su vez en el método de de bajo nivel de
DynamoDBAmazonDynamoDBClient.QueryAsyncPara recuperar los resultados de la consulta.
Note

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)

Paso 9: Analizar la tabla Movies con .NET


En este paso de laTutorial de Microsoft NET y DynamoDB (p. 142), escanea elMoviesEn este cuadro se
utilizan dos opciones distintas: mediante un examen de modelo de documento y un examen de bajo nivel.

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)

Versión de API 2012-08-10


157
Amazon DynamoDB Guía para desarrolladores
Paso 9: Examen de una tabla

• Paso siguiente (p. 158)

Utilice una búsqueda de modelo de documento para analizar


películas de los años 50
Para configurar un análisis de modelo de documentos para películas de los años 50, la función Main en
DynamoDB_intro crea un objeto ScanOperationConfig con un ScanFilter:

ScanFilter filter = new ScanFilter( );


filter.AddCondition( "year", ScanOperator.Between, new DynamoDBEntry[ ] { 1950,
1959 } );
ScanOperationConfig scanConfig = new ScanOperationConfig
{
AttributesToGet = new List<string> { "year, title, info" },
Filter = filter
};

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.

Utilizar un análisis de bajo nivel para recuperar películas de los


años 60
Para configurar un análisis de bajo nivel para películas de los años 60, la función Main en
DynamoDB_intro crea un objeto ScanRequest con varios campos.

ScanRequest sRequest = new ScanRequest


{
TableName = "Movies",
ExpressionAttributeNames = new Dictionary<string, string>
{
{ "#yr", "year" }
},
ExpressionAttributeValues = new Dictionary<string, AttributeValue>
{
{ ":y_a", new AttributeValue { N = "1960" } },
{ ":y_z", new AttributeValue { N = "1969" } },
},
FilterExpression = "#yr between :y_a and :y_z",
ProjectionExpression = "#yr, title, info.actors[0], info.directors,
info.running_time_secs"
};

A continuación, espera en elClientScanning_asyncimplementada en


el09_Scanninging.csfile.ClientScanning_asyncespera a su vez en el método de de bajo nivel de
DynamoDBAmazonDynamoDBClient.ScanAsyncPara recuperar los resultados de la consulta.
Note

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)

Versión de API 2012-08-10


158
Amazon DynamoDB Guía para desarrolladores
Paso 10: Eliminar la tabla

Paso 10: Eliminación de la tabla Movies con .NET


En este paso de laTutorial de Microsoft NET y DynamoDB (p. 142), elimine elMoviesEn Amazon
DynamoDB.

La función Main en DynamoDB_intro espera en DeletingTable_async, que está implementada en el


archivo 10_DeletingTable.cs.

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;
}
}
}

DeletingTable_asyncespera en el método de de bajo nivel de


DynamoDBAmazonDynamoDBClient.DeleteTableAsyncPara eliminar la tabla.

Para obtener más información


• Para obtener más información sobre cómo leer y escribir datos en tablas de DynamoDB, consulte.Uso
de elementos y atributos (p. 410).
• Para obtener más información sobre la API del modelo de documento de DynamoDB, consulte..NET:
Modelo de documento (p. 279).
• Para obtener más información sobre métodos asíncronos, consulte.AWSAPI asincrónicas de para .NET.

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.

Requisitos previos del tutorial


• Descargue y ejecute DynamoDB en el equipo. Para obtener más información, consulte Configuración de
DynamoDB Local (versión descargable) (p. 50).

Versión de API 2012-08-10


159
Amazon DynamoDB Guía para desarrolladores
Paso 1: Crear una tabla

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.

Paso 1: Crear una tabla


En este paso, se crea una tabla denominada Movies. La clave principal de la tabla se compone de los dos
atributos siguientes:

• year: clave de partición. El valor de AttributeType es N si es numérico.


• title: clave de ordenación. El valor de AttributeType es S si es de cadena.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesCreateTable.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;

$sdk = new Aws\Sdk([


'endpoint' => 'http://localhost:8000',
'region' => 'us-west-2',
'version' => 'latest'
]);

$dynamodb = $sdk->createDynamoDb();

$params = [
'TableName' => 'Movies',
'KeySchema' => [
[
'AttributeName' => 'year',
'KeyType' => 'HASH' //Partition key
],

Versión de API 2012-08-10


160
Amazon DynamoDB Guía para desarrolladores
Paso 2: Carga de ejemplos de datos

[
'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";

} catch (DynamoDbException $e) {


echo "Unable to create table:\n";
echo $e->getMessage() . "\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).

Paso 2: Carga de ejemplos de datos


En este paso, se rellena la tabla Movies con ejemplos de datos.

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)

Versión de API 2012-08-10


161
Amazon DynamoDB Guía para desarrolladores
Paso 2: Carga de ejemplos de datos

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" : { ... }
},

...

En los datos de JSON, tenga en cuenta lo siguiente:

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

A continuación, se muestra un ejemplo de datos de películas.

{
"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"
]
}
}

Paso 2.1: Descargue el archivo de datos de ejemplo


1. Descargue el archivo de datos de ejemplo: moviedata.zip

Versión de API 2012-08-10


162
Amazon DynamoDB Guía para desarrolladores
Paso 2: Carga de ejemplos de datos

2. Extraiga el archivo de datos (moviedata.json) del archivo comprimido.


3. Copie y pegue el archivo moviedata.json en el directorio actual.

Paso 2.2: Cargue los ejemplos de datos en la tabla Movies


Después de descargar los datos de ejemplo, puede ejecutar el programa siguiente para rellenar la tabla
Movies.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesLoadData.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;

$sdk = new Aws\Sdk([


'endpoint' => 'http://localhost:8000',
'region' => 'us-west-2',
'version' => 'latest'
]);

$dynamodb = $sdk->createDynamoDb();
$marshaler = new Marshaler();

$tableName = 'Movies';

$movies = json_decode(file_get_contents('moviedata.json'), true);

foreach ($movies as $movie) {

$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)
];

Versión de API 2012-08-10


163
Amazon DynamoDB Guía para desarrolladores
Paso 3: Crear, leer, actualizar y eliminar elementos

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

LaClase DynamoDB MarshalerTiene métodos para convertir documentos JSON


y matrices de PHP al formato de DynamoDB. En este programa,$marshaler-
>marshalJson($json)toma un documento JSON y lo convierte en un elemento
DynamoDB.
2. Para ejecutar el programa, introduzca el siguiente comando.

php MoviesLoadData.php

Paso 3: Crear, leer, actualizar y eliminar elementos


En este paso, se llevan a cabo operaciones de lectura y escritura con un elemento de la tabla Movies.

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)

Paso 3.1: Crear un elemento nuevo


En este paso, agregamos un elemento nuevo a la tabla Movies.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps01.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

Versión de API 2012-08-10


164
Amazon DynamoDB Guía para desarrolladores
Paso 3: Crear, leer, actualizar y eliminar elementos

* 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;

$sdk = new Aws\Sdk([


'endpoint' => 'http://localhost:8000',
'region' => 'us-west-2',
'version' => 'latest'
]);

$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";

} catch (DynamoDbException $e) {


echo "Unable to add item:\n";
echo $e->getMessage() . "\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

Versión de API 2012-08-10


165
Amazon DynamoDB Guía para desarrolladores
Paso 3: Crear, leer, actualizar y eliminar elementos

Paso 3.2: Lea un elemento


En el programa anterior, hemos agregado el elemento siguiente a la tabla.

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

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps02.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;

$sdk = new Aws\Sdk([


'endpoint' => 'http://localhost:8000',
'region' => 'us-west-2',
'version' => 'latest'
]);

$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,

Versión de API 2012-08-10


166
Amazon DynamoDB Guía para desarrolladores
Paso 3: Crear, leer, actualizar y eliminar elementos

'Key' => $key


];

try {
$result = $dynamodb->getItem($params);
print_r($result["Item"]);

} catch (DynamoDbException $e) {


echo "Unable to get item:\n";
echo $e->getMessage() . "\n";
}

2. Para ejecutar el programa, introduzca el siguiente comando.

php MoviesItemOps02.php

Paso 3.3: Actualización de un elemento


Puede utilizar el método updateItem para modificar un elemento existente. Puede actualizar los valores
de los atributos existentes, así como agregar atributos nuevos o eliminarlos.

En este ejemplo, se llevan a cabo las siguientes actualizaciones:

• Cambie el valor de los atributos existentes (rating, plot).


• Agregue un nuevo atributo de lista (actors) al mapa info existente.

A continuación se muestra el elemento existente.

{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}

El elemento se actualiza como se indica a continuación.

{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Everything happens all at once.",
rating: 5.5,
actors: ["Larry", "Moe", "Curly"]
}
}

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps03.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").

Versión de API 2012-08-10


167
Amazon DynamoDB Guía para desarrolladores
Paso 3: Crear, leer, actualizar y eliminar elementos

* 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;

$sdk = new Aws\Sdk([


'endpoint' => 'http://localhost:8000',
'region' => 'us-west-2',
'version' => 'latest'
]);

$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']);

} catch (DynamoDbException $e) {


echo "Unable to update item:\n";
echo $e->getMessage() . "\n";
}

Versión de API 2012-08-10


168
Amazon DynamoDB Guía para desarrolladores
Paso 3: Crear, leer, actualizar y eliminar elementos

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

Paso 3.4: Incremento de un contador atómico


DynamoDB admite contadores atómicos, que utilizan elupdateItemPara aumentar o reducir el valor de un
atributo sin interferir con otras solicitudes de escritura. Todas las solicitudes de escritura se aplican en el
orden en que se reciben.

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.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps04.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;

$sdk = new Aws\Sdk([


'endpoint' => 'http://localhost:8000',
'region' => 'us-west-2',
'version' => 'latest'
]);

$dynamodb = $sdk->createDynamoDb();
$marshaler = new Marshaler();

$tableName = 'Movies';

$year = 2015;
$title = 'The Big New Movie';

$key = $marshaler->marshalJson('

Versión de API 2012-08-10


169
Amazon DynamoDB Guía para desarrolladores
Paso 3: Crear, leer, actualizar y eliminar elementos

{
"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']);

} catch (DynamoDbException $e) {


echo "Unable to update item:\n";
echo $e->getMessage() . "\n";
}

2. Para ejecutar el programa, introduzca el siguiente comando.

php MoviesItemOps04.php

Paso 3.5: Actualización de un elemento (condicionalmente)


El programa siguiente muestra cómo usar UpdateItem con una condición. Si la condición se evalúa en
true (verdadero), la actualización se lleva a cabo correctamente; de lo contrario, la actualización no se
realiza.

En este caso, el elemento se actualiza solamente si hay más de tres actores en la película.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps05.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';

Versión de API 2012-08-10


170
Amazon DynamoDB Guía para desarrolladores
Paso 3: Crear, leer, actualizar y eliminar elementos

date_default_timezone_set('UTC');

use Aws\DynamoDb\Exception\DynamoDbException;
use Aws\DynamoDb\Marshaler;

$sdk = new Aws\Sdk([


'endpoint' => 'http://localhost:8000',
'region' => 'us-west-2',
'version' => 'latest'
]);

$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']);

} catch (DynamoDbException $e) {


echo "Unable to update item:\n";
echo $e->getMessage() . "\n";
}

2. Para ejecutar el programa, introduzca el siguiente comando.

php MoviesItemOps05.php

Debe producirse un error en el programa y mostrar el mensaje siguiente.

The conditional request failed (Error en la solicitud condicional)

El progama falla porque la película tiene tres actores, pero la condición busca un valor mayor que tres
actores.

Versión de API 2012-08-10


171
Amazon DynamoDB Guía para desarrolladores
Paso 3: Crear, leer, actualizar y eliminar elementos

3. Modifique el programa para que ConditionExpression tenga el aspecto siguiente.

ConditionExpression="size(info.actors) >= :num",

Ahora, la condición es mayor o igual que 3 en lugar de mayor que 3.


4. Ejecute el programa de nuevo. Ahora, la operación UpdateItem debería realizarse correctamente.

Paso 3.6: Eliminación de un elemento


Puede utilizar el método deleteItem para eliminar un elemento especificando su clave principal. También
puede incluir una instrucción ConditionExpression para evitar que se elimine el elemento si no se
cumple la condición.

En el siguiente ejemplo, se intenta eliminar un elemento de película determinado si su calificación es igual


o menor que 5.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps06.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;

$sdk = new Aws\Sdk([


'endpoint' => 'http://localhost:8000',
'region' => 'us-west-2',
'version' => 'latest'
]);

$dynamodb = $sdk->createDynamoDb();
$marshaler = new Marshaler();

$tableName = 'Movies';

$year = 2015;
$title = 'The Big New Movie';

$key = $marshaler->marshalJson('
{
"year": ' . $year . ',
"title": "' . $title . '"
}
');

Versión de API 2012-08-10


172
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

$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";

} catch (DynamoDbException $e) {


echo "Unable to delete item:\n";
echo $e->getMessage() . "\n";
}

2. Para ejecutar el programa, introduzca el siguiente comando.

php MoviesItemOps06.php

Debe producirse un error en el programa y mostrar el mensaje siguiente.

The conditional request failed (Error en la solicitud condicional)

El programa falla porque la calificación de esta película concreta es mayor que 5.


3. Modifique el programa para eliminar la condición de.

$params = [
'TableName' => $tableName,
'Key' => $key
];

4. Ejecute el programa. Ahora, la eliminación se llevará a cabo correctamente porque se ha eliminado la


condición.

Paso 4: Consulta y examen de los datos


Puede utilizar el método query para recuperar datos de una tabla. Debe especificar un valor de clave de
partición. La clave de ordenación es opcional.

La clave principal de la tabla Movies consta de:

• year: clave de partición. El tipo de atributo es number. 


• title: clave de ordenación. El tipo de atributo es string.

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.

Versión de API 2012-08-10


173
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

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)

Paso 4.1: Consulta - Todas las películas estrenadas durante un


año
El programa incluido en este paso recupera todas las películas estrenadas en el año (year) 1985.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesQuery01.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;

$sdk = new Aws\Sdk([


'endpoint' => 'http://localhost:8000',
'region' => 'us-west-2',
'version' => 'latest'
]);

$dynamodb = $sdk->createDynamoDb();
$marshaler = new Marshaler();

$tableName = 'Movies';

$eav = $marshaler->marshalJson('
{
":yyyy": 1985
}
');

$params = [
'TableName' => $tableName,
'KeyConditionExpression' => '#yr = :yyyy',
'ExpressionAttributeNames'=> [ '#yr' => 'year' ],
'ExpressionAttributeValues'=> $eav

Versión de API 2012-08-10


174
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

];

echo "Querying for movies from 1985.\n";

try {
$result = $dynamodb->query($params);

echo "Query succeeded.\n";

foreach ($result['Items'] as $movie) {


echo $marshaler->unmarshalValue($movie['year']) . ': ' .
$marshaler->unmarshalValue($movie['title']) . "\n";
}

} catch (DynamoDbException $e) {


echo "Unable to query:\n";
echo $e->getMessage() . "\n";
}

Note

• ExpressionAttributeNames permite sustituir nombres. Usamos esto porqueyearEs


una palabra reservada en DynamoDB, por lo que no se puede utilizar directamente en una
expresión, incluidaKeyConditionExpression. Puede usar el nombre de atributo de
expresión #yr para solucionar el problema.
• ExpressionAttributeValues permite sustituir valores. Lo utilizamos porque no se
pueden utilizar literales en ninguna expresión, incluida KeyConditionExpression.
Puede usar el valor de atributo de expresión :yyyy para solucionar el problema.
2. Para ejecutar el programa, introduzca el siguiente comando:

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

Paso 4.2: Consulta - Todas las películas estrenadas durante un


año con unos títulos determinados
El programa incluido en este paso recupera todas las películas estrenadas el año (year) 1992, cuyo título
(title) comienza por las letras de la "A" a la "L".

1. Copie el siguiente programa y péguelo en un archivo llamado 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
*

Versión de API 2012-08-10


175
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

* 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;

$sdk = new Aws\Sdk([


'endpoint' => 'http://localhost:8000',
'region' => 'us-west-2',
'version' => 'latest'
]);

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

echo "Query succeeded.\n";

foreach ($result['Items'] as $i) {


$movie = $marshaler->unmarshalItem($i);
print $movie['year'] . ': ' . $movie['title'] . ' ... ';

foreach ($movie['info']['genres'] as $gen) {


print $gen . ' ';
}

echo ' ... ' . $movie['info']['actors'][0] . "\n";


}

} catch (DynamoDbException $e) {


echo "Unable to query:\n";
echo $e->getMessage() . "\n";
}

Versión de API 2012-08-10


176
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

2. Para ejecutar el programa, introduzca el siguiente comando.

php MoviesQuery02.php

Paso 4.3: Examen


LascanEl método lee cada uno de los elementos de la tabla y devuelve todos los datos de la tabla.
Puede proporcionar una expresión filter_expression opcional para que solamente se devuelvan los
elementos que coinciden con los criterios. No obstante, el filtro solo se aplica después de haber examinado
toda la tabla.

El programa siguiente examina la tabla Movies en su totalidad, que contiene aproximadamente


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

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesScan.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;

$sdk = new Aws\Sdk([


'endpoint' => 'http://localhost:8000',
'region' => 'us-west-2',
'version' => 'latest'
]);

$dynamodb = $sdk->createDynamoDb();

$marshaler = new Marshaler();

//Expression attribute values


$eav = $marshaler->marshalJson('
{
":start_yr": 1950,
":end_yr": 1959
}
');

$params = [
'TableName' => 'Movies',
'ProjectionExpression' => '#yr, title, info.rating',

Versión de API 2012-08-10


177
Amazon DynamoDB Guía para desarrolladores
Paso 5: (Opcional) Eliminar la tabla

'FilterExpression' => '#yr between :start_yr and :end_yr',


'ExpressionAttributeNames'=> [ '#yr' => 'year' ],
'ExpressionAttributeValues'=> $eav
];

echo "Scanning Movies table.\n";

try {
while (true) {
$result = $dynamodb->scan($params);

foreach ($result['Items'] as $i) {


$movie = $marshaler->unmarshalItem($i);
echo $movie['year'] . ': ' . $movie['title'];
echo ' ... ' . $movie['info']['rating']
. "\n";
}

if (isset($result['LastEvaluatedKey'])) {
$params['ExclusiveStartKey'] = $result['LastEvaluatedKey'];
} else {
break;
}
}

} catch (DynamoDbException $e) {


echo "Unable to scan:\n";
echo $e->getMessage() . "\n";
}

En el código, observe lo siguiente:

• ProjectionExpression especifica los atributos que se desea obtener en el resultado del


examen.
• FilterExpression especifica una condición que devuelve solamente los elementos que cumplen
la condición. Todos los demás elementos se descartan.
2. Para ejecutar el programa, introduzca el siguiente comando.

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

Paso 5: (Opcional) Eliminar la tabla


Para eliminar la tabla Movies:

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesDeleteTable.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").

Versión de API 2012-08-10


178
Amazon DynamoDB Guía para desarrolladores
Summary

* 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;

$sdk = new Aws\Sdk([


'endpoint' => 'http://localhost:8000',
'region' => 'us-west-2',
'version' => 'latest'
]);

$dynamodb = $sdk->createDynamoDb();

$params = [
'TableName' => 'Movies'
];

try {
$result = $dynamodb->deleteTable($params);
echo "Deleted table.\n";

} catch (DynamoDbException $e) {


echo "Unable to delete table:\n";
echo $e->getMessage() . "\n";
}

2. Para ejecutar el programa, introduzca el siguiente comando.

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.

Modificación del código para utilizar el servicio DynamoDB


Debe cambiar el punto de enlace en la aplicación para usar el servicio web de DynamoDB. Para ello,
busque las siguientes líneas en el código.

$sdk = new Aws\Sdk([


'endpoint' => 'http://localhost:8000',
'region' => 'us-west-2',
'version' => 'latest'
]);

Versión de API 2012-08-10


179
Amazon DynamoDB Guía para desarrolladores
Python y DynamoDB

Elimine elendpointparámetro para que el código tenga el aspecto siguiente.

$sdk = new Aws\Sdk([


'region' => 'us-west-2',
'version' => 'latest'
]);

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

'region' => 'us-west-2',

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.

Introducción al desarrollo con Python y DynamoDB


En este tutorial, utilizaremos laAWS SDK for Python (Boto3)Para 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 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

Requisitos previos del tutorial


• Descargue y ejecute DynamoDB en su equipo. 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. En el


navegadorSummary (p. 194), explicamos cómo ejecutar el mismo código en el servicio web
de DynamoDB.
• Configurar unAWSpara utilizar la clave de accesoAWSSDK de. Para obtener más información, consulte
Configuración de DynamoDB (servicio web) (p. 57).
• Instale Python 2.6 o posterior. Para obtener más información, consulte https://www.python.org/
downloads. Para obtener instrucciones, consulte Quickstart en la documentación de Boto 3.

Versión de API 2012-08-10


180
Amazon DynamoDB Guía para desarrolladores
Paso 1: Crear una tabla

Paso 1: Creación de una tabla con Python


En este paso, se crea una tabla denominada Movies. La clave principal de la tabla se compone de los
siguientes atributos:

• year: clave de partición. El valor de AttributeType es N si es numérico.


• title: clave de ordenación. El valor de AttributeType es S si es de cadena.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesCreateTable.py.

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.

Versión de API 2012-08-10


181
Amazon DynamoDB Guía para desarrolladores
Paso 2: Carga de ejemplos de datos

• El parámetro ProvisionedThroughput 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.
• En estos ejemplos se utiliza la función print de estilo de Python 3. La línea from
__future__ import print_function permite que Python 3 imprima en Python 2.6 y
versiones posteriores.
2. Para ejecutar el programa, introduzca el siguiente comando.

python MoviesCreateTable.py

Para obtener más información sobre cómo administrar tablas, consulte Uso de tablas y datos en
DynamoDB (p. 344).

Paso 2: Carga de ejemplos de datos


En este paso, se rellena la tabla Movies con ejemplos de datos.

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" : { ... }
},

...

En los datos de JSON, tenga en cuenta lo siguiente:

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

A continuación, se muestra un ejemplo de datos de películas.

{
"year" : 2013,
"title" : "Turn It Down, Or Else!",
"info" : {
"directors" : [

Versión de API 2012-08-10


182
Amazon DynamoDB Guía para desarrolladores
Paso 2: Carga de ejemplos de datos

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

Paso 2.1: Descargue el archivo de datos de ejemplo


1. Descargue el archivo de datos de ejemplo: moviedata.zip
2. Extraiga el archivo de datos (moviedata.json) del archivo comprimido.
3. Copie el archivo moviedata.json en el directorio actual.

Paso 2.2: Cargue los ejemplos de datos en la tabla Movies


Después de descargar los datos de ejemplo, puede ejecutar el programa siguiente para rellenar la tabla
Movies.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesLoadData.py.

from decimal import Decimal


import json
import boto3

def load_movies(movies, dynamodb=None):


if not dynamodb:
dynamodb = boto3.resource('dynamodb', endpoint_url="http://localhost:8000")

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)

2. Para ejecutar el programa, introduzca el siguiente comando.

python MoviesLoadData.py

Versión de API 2012-08-10


183
Amazon DynamoDB Guía para desarrolladores
Paso 3: Operaciones de CRUD

Paso 3: Creación, lectura, actualización y eliminación


de elementos con Python
En este paso, se llevan a cabo operaciones de lectura y escritura con un elemento de la tabla Movies.

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)

Paso 3.1: Creación de un elemento nuevo


En este paso, agregamos un elemento nuevo a la tabla Movies.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps01.py.

from pprint import pprint


import boto3

def put_movie(title, year, plot, rating, dynamodb=None):


if not dynamodb:
dynamodb = boto3.resource('dynamodb', endpoint_url="http://localhost:8000")

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

• La clase DecimalEncoder se utiliza para imprimir números almacenados mediante la


clase Decimal. El Boto SDK utiliza elDecimalpara contener los valores numéricos de
Amazon DynamoDB.
2. Para ejecutar el programa, introduzca el siguiente comando.

python MoviesItemOps01.py

Paso 3.2: Lectura de un elemento


En el programa anterior, hemos agregado el elemento siguiente a la tabla.

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

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps02.py.

from pprint import pprint


import boto3
from botocore.exceptions import ClientError

def get_movie(title, year, dynamodb=None):


if not dynamodb:
dynamodb = boto3.resource('dynamodb', endpoint_url="http://localhost:8000")

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)

2. Para ejecutar el programa, introduzca el siguiente comando.

python MoviesItemOps02.py

Paso 3.3: Actualización de un elemento


Puede utilizar el método update_item para modificar un elemento existente. Puede actualizar los valores
de los atributos existentes, así como agregar atributos nuevos o eliminarlos.

Versión de API 2012-08-10


185
Amazon DynamoDB Guía para desarrolladores
Paso 3: Operaciones de CRUD

En este ejemplo, se llevan a cabo las siguientes actualizaciones:

• Cambie el valor de los atributos existentes (rating, plot).


• Agregue un nuevo atributo de lista (actors) al mapa info existente.

A continuación se muestra el elemento existente.

{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}

El elemento se actualiza como se indica a continuación.

{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Everything happens all at once.",
rating: 5.5,
actors: ["Larry", "Moe", "Curly"]
}
}

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps03.py.

from decimal import Decimal


from pprint import pprint
import boto3

def update_movie(title, year, rating, plot, actors, dynamodb=None):


if not dynamodb:
dynamodb = boto3.resource('dynamodb', endpoint_url="http://localhost:8000")

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

Versión de API 2012-08-10


186
Amazon DynamoDB Guía para desarrolladores
Paso 3: Operaciones de CRUD

print("Update movie succeeded:")


pprint(update_response, sort_dicts=False)

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

Paso 3.4: Incrementar un contador atómico


DynamoDB admite contadores atómicos, que utilizan elupdate_itemUtilice el método para aumentar
o reducir el valor de un atributo sin interferir con otras solicitudes de escritura. Todas las solicitudes de
escritura se aplican en el orden en que se reciben.

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.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps04.py.

from decimal import Decimal


from pprint import pprint
import boto3

def increase_rating(title, year, rating_increase, dynamodb=None):


if not dynamodb:
dynamodb = boto3.resource('dynamodb', endpoint_url="http://localhost:8000")

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)

2. Para ejecutar el programa, introduzca el siguiente comando.

python MoviesItemOps04.py

Versión de API 2012-08-10


187
Amazon DynamoDB Guía para desarrolladores
Paso 3: Operaciones de CRUD

Paso 3.5: Actualización de un elemento (condicionalmente)


El programa siguiente muestra cómo usar UpdateItem con una condición. Si la condición se evalúa en
true (verdadero), la actualización se lleva a cabo correctamente; de lo contrario, la actualización no se
realiza.

En este caso, el elemento se actualiza solamente si hay más de tres actores.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps05.py.

from pprint import pprint


import boto3
from botocore.exceptions import ClientError

def remove_actors(title, year, actor_count, dynamodb=None):


if not dynamodb:
dynamodb = boto3.resource('dynamodb', endpoint_url="http://localhost:8000")

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)

2. Para ejecutar el programa, introduzca el siguiente comando.

python MoviesItemOps05.py

Debe producirse un error en el programa y mostrar el mensaje siguiente.

The conditional request failed (Error en la solicitud condicional)

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.

ConditionExpression="size(info.actors) >= :num",

Versión de API 2012-08-10


188
Amazon DynamoDB Guía para desarrolladores
Paso 3: Operaciones de CRUD

Ahora, la condición es mayor o igual que 3 en lugar de mayor que 3.


4. Ejecute el programa de nuevo. Ahora, la operación UpdateItem debería realizarse correctamente.

Paso 3.6: Eliminación de un elemento


Puede utilizar el método delete_item para eliminar un elemento especificando su clave principal.
Opcionalmente, puede incluir una instrucción ConditionExpression para evitar que se elimine el
elemento si no se cumple la condición.

En el siguiente ejemplo, se intenta eliminar un elemento de película determinado si su calificación es igual


o menor que 5.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps06.py.

from decimal import Decimal


from pprint import pprint
import boto3
from botocore.exceptions import ClientError

def delete_underrated_movie(title, year, rating, dynamodb=None):


if not dynamodb:
dynamodb = boto3.resource('dynamodb', endpoint_url="http://localhost:8000")

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)

2. Para ejecutar el programa, introduzca el siguiente comando.

python MoviesItemOps06.py

Debe producirse un error en el programa y mostrar el mensaje siguiente.

The conditional request failed (Error en la solicitud condicional)

Versión de API 2012-08-10


189
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

El programa falla porque la calificación de esta película concreta es mayor que 5.


3. Modifique el programa para eliminar la condición de table.delete_item.

response = table.delete_item(
Key={
'year': year,
'title': title
}
)

4. Ejecute el programa. Ahora, la eliminación se llevará a cabo correctamente porque se ha eliminado la


condición.

Paso 4: Consulta y examen de los datos


Puede utilizar el método query para recuperar datos de una tabla. Debe especificar un valor de clave de
partición. La clave de ordenación es opcional.

La clave principal de la tabla Movies consta de:

• year: clave de partición. El tipo de atributo es number. 


• title: clave de ordenación. El tipo de atributo es string.

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)

Paso 4.1: Consulta de todas las películas estrenadas durante un


año
El programa incluido en este paso recupera todas las películas estrenadas en el año (year) 1985.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesQuery01.py.

import boto3
from boto3.dynamodb.conditions import Key

def query_movies(year, dynamodb=None):


if not dynamodb:

Versión de API 2012-08-10


190
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

dynamodb = boto3.resource('dynamodb', endpoint_url="http://localhost:8000")

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

El SDK de Boto 3 SDK crea una ConditionExpression automáticamente cuando se


utilizan las funciones Key y Attr importadas de boto3.dynamodb.conditions. También
puede especificar una ConditionExpression como una cadena.
Para obtener una lista de condiciones disponibles para Amazon DynamoDB,
consulteCondiciones de DynamoDBinAWSIntroducción al SDK for Python (Boto3).
Para obtener más información, consulte Expresiones de condición (p. 428).
2. Para ejecutar el programa, introduzca el siguiente comando.

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

Paso 4.2: Consulta de todas las películas estrenadas durante un


año con unos títulos determinados
El programa incluido en este paso recupera todas las películas estrenadas el año (year) 1992, cuyo título
(title) comienza por las letras de la "A" a la "L".

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesQuery02.py.

from pprint import pprint


import boto3
from boto3.dynamodb.conditions import Key

def query_and_project_movies(year, title_range, dynamodb=None):


if not dynamodb:
dynamodb = boto3.resource('dynamodb', endpoint_url="http://localhost:8000")

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]",

Versión de API 2012-08-10


191
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

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

2. Para ejecutar el programa, introduzca el siguiente comando.

python MoviesQuery02.py

Paso 4.3: Examen


El método scan lee cada uno de los elementos de la tabla y devuelve todos los datos de la tabla. Puede
proporcionar una expresión filter_expression opcional para que solamente se devuelvan los
elementos que coinciden con los criterios. No obstante, el filtro solo se aplica después de haber examinado
toda la tabla.

El programa siguiente examina la tabla Movies en su totalidad, que contiene aproximadamente


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

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesScan.py.

from pprint import pprint


import boto3
from boto3.dynamodb.conditions import Key

def scan_movies(year_range, display_movies, dynamodb=None):


if not dynamodb:
dynamodb = boto3.resource('dynamodb', endpoint_url="http://localhost:8000")

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__':

Versión de API 2012-08-10


192
Amazon DynamoDB Guía para desarrolladores
Paso 5: (Opcional) Eliminar la tabla

def print_movies(movies):
for movie in movies:
print(f"\n{movie['year']} : {movie['title']}")
pprint(movie['info'])

query_range = (1950, 1959)


print(f"Scanning for movies released from {query_range[0]} to {query_range[1]}...")
scan_movies(query_range, print_movies)

En el código, observe lo siguiente:

• ProjectionExpression especifica los atributos que se desea obtener en el resultado del


examen.
• FilterExpression especifica una condición que devuelve solamente los elementos que cumplen
la condición. Todos los demás elementos se descartan.
• El método scan devuelve cada vez un subconjunto de los elementos, que se denomina página. A
continuación, el valor de LastEvaluatedKey de la respuesta se pasa al método scan a través del
parámetro ExclusiveStartKey. Cuando se devuelve la última página, LastEvaluatedKey no
forma parte de la respuesta.

Note

• ExpressionAttributeNames permite sustituir nombres. Usamos esto porqueyeares


una palabra reservada en DynamoDB, por lo que no se puede utilizar directamente en una
expresión, incluidaKeyConditionExpression. Puede usar el nombre de atributo de
expresión #yr para solucionar el problema.
• ExpressionAttributeValues permite sustituir valores. Lo utilizamos porque no se
pueden utilizar literales en ninguna expresión, incluida KeyConditionExpression.
Puede usar el valor de atributo de expresión :yyyy para solucionar el problema.
2. Para ejecutar el programa, introduzca el siguiente comando.

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

Paso 5: (Opcional) Eliminar la tabla


Para eliminar la tabla Movies:

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesDeleteTable.py.

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

2. Para ejecutar el programa, introduzca el siguiente comando.

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.

Modificación del código para utilizar el servicio de DynamoDB


Debe cambiar el punto de enlace en la aplicación para usar el servicio web de DynamoDB. Para ello,
modifique la línea siguiente.

dynamodb = boto3.resource('dynamodb',endpoint_url="http://localhost:8000")

Por ejemplo, si desea utilizar la región us-west-2, cambie el código al siguiente.

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.

Requisitos previos del tutorial


• Descargue y ejecute DynamoDB en el equipo. Para obtener más información, consulte Configuración de
DynamoDB Local (versión descargable) (p. 50).

Versión de API 2012-08-10


194
Amazon DynamoDB Guía para desarrolladores
Paso 1: Crear una tabla

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 web de DynamoDB, consulte
elSummary (p. 212).
• Configure unaAWSpara 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 Ruby:
• InstallRuby.
• Instale la AWS SDK for Ruby.

Para obtener más información, consulteInstalación deen laAWS SDK for RubyReferencia de la API.

Paso 1: Crear una tabla


En este paso, se crea una tabla denominadaMoviesEn Amazon DynamoDB. La clave principal de la tabla
se compone de los dos atributos siguientes:

• year: clave de partición. El valor de attribute_type es N si es numérico. 


• title: clave de ordenación. El valor de attribute_type es S si es de cadena.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesCreateTable.rb.

require 'aws-sdk-dynamodb'

def create_table(dynamodb_client, table_definition)


response = dynamodb_client.create_table(table_definition)
response.table_description.table_status
rescue StandardError => e
puts "Error creating table: #{e.message}"
'Error'
end

def run_me
region = 'us-west-2'

# To use the downloadable version of Amazon DynamoDB,


# uncomment the endpoint statement.
Aws.config.update(
# endpoint: 'http://localhost:8000',
region: region
)

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: [

Versión de API 2012-08-10


195
Amazon DynamoDB Guía para desarrolladores
Paso 2: Carga de ejemplos de datos

{
attribute_name: 'year',
attribute_type: 'N'
},
{
attribute_name: 'title',
attribute_type: 'S'
}
],
provisioned_throughput: {
read_capacity_units: 10,
write_capacity_units: 10
}
}

puts "Creating the table named 'Movies'..."


create_table_result = create_table(dynamodb_client, table_definition)

if create_table_result == 'Error'
puts 'Table not created.'
else
puts "Table created with status '#{create_table_result}'."
end
end

run_me if $PROGRAM_NAME == __FILE__

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

Paso 2: Carga de ejemplos de datos


En este paso, se rellena elMoviesen Amazon DynamoDB con datos de ejemplo.

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.

Versión de API 2012-08-10


196
Amazon DynamoDB Guía para desarrolladores
Paso 2: Carga de ejemplos de datos

{
"year" : ... ,
"title" : ... ,
"info" : { ... }
},
{
"year" : ...,
"title" : ...,
"info" : { ... }
},

...

En los datos de JSON, tenga en cuenta lo siguiente:

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

A continuación, se muestra un ejemplo de datos de películas.

{
"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"
]
}
}

Paso 2.1: Descargue el archivo de datos de ejemplo


1. Descargue el archivo de datos de ejemplo: moviedata.zip
2. Extraiga el archivo de datos (moviedata.json) del archivo comprimido.
3. Copie elmoviedata.jsony péguelo en el directorio actual.

Versión de API 2012-08-10


197
Amazon DynamoDB Guía para desarrolladores
Paso 2: Carga de ejemplos de datos

Paso 2.2: Cargue los ejemplos de datos en la tabla Movies


Después de descargar los ejemplos de datos, ejecute el programa siguiente para rellenar elMoviesTabla
de.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesLoadData.rb.

require 'aws-sdk-dynamodb'
require 'json'

$movie_counter = 0
$total_movies = 0

def add_item_to_table(dynamodb_client, table_item)


dynamodb_client.put_item(table_item)
$movie_counter += 1
puts "Added movie #{$movie_counter}/#{$total_movies}: " \
"'#{table_item[:item]['title']} " \
"(#{table_item[:item]['year']})'."
rescue StandardError => e
puts "Error adding movie '#{table_item[:item]['title']} " \
"(#{table_item[:item]['year']})': #{e.message}"
puts 'Program stopped.'
exit 1
end

def run_me
region = 'us-west-2'
table_name = 'Movies'
data_file = 'moviedata.json'

# To use the downloadable version of Amazon DynamoDB,


# uncomment the endpoint statement.
Aws.config.update(
# endpoint: 'http://localhost:8000',
region: region
)

dynamodb_client = Aws::DynamoDB::Client.new
file = File.read(data_file)
movies = JSON.parse(file)
$total_movies = movies.count

puts "Adding #{$total_movies} movies from file '#{data_file}' " \


"into table '#{table_name}'..."

movies.each do |movie|
table_item = {
table_name: table_name,
item: movie
}
add_item_to_table(dynamodb_client, table_item)
end

puts 'Done.'
end

run_me if $PROGRAM_NAME == __FILE__

2. Para ejecutar el programa, introduzca el siguiente comando.

ruby MoviesLoadData.rb

Versión de API 2012-08-10


198
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

Paso 3: Creación, lectura, actualización y eliminación


de elementos
En este paso, se llevan a cabo operaciones de lectura y escritura con un elemento de la regiónMoviesEn
Amazon DynamoDB.

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)

Paso 3.1: Creación de un elemento nuevo


En este paso, agregamos un elemento nuevo a la tabla .

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps01.rb.

require 'aws-sdk-dynamodb'

def add_item_to_table(dynamodb_client, table_item)


dynamodb_client.put_item(table_item)
puts "Added movie '#{table_item[:item][:title]} " \
"(#{table_item[:item][:year]})'."
rescue StandardError => e
puts "Error adding movie '#{table_item[:item][:title]} " \
"(#{table_item[:item][:year]})': #{e.message}"
end

def run_me
region = 'us-west-2'
table_name = 'Movies'
title = 'The Big New Movie'
year = 2015

# To use the downloadable version of Amazon DynamoDB,


# uncomment the endpoint statement.
Aws.config.update(
# endpoint: 'http://localhost:8000',
region: region
)

dynamodb_client = Aws::DynamoDB::Client.new

item = {
year: year,
title: title,
info: {
plot: 'Nothing happens at all.',
rating: 0
}
}

Versión de API 2012-08-10


199
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

table_item = {
table_name: table_name,
item: item
}

puts "Adding movie '#{item[:title]} (#{item[:year]})' " \


"to table '#{table_name}'..."
add_item_to_table(dynamodb_client, table_item)
end

run_me if $PROGRAM_NAME == __FILE__

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

Paso 3.2: Lea un elemento


En el programa anterior, hemos agregado el elemento siguiente a la tabla.

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

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps02.rb.

require 'aws-sdk-dynamodb'

def get_item_from_table(dynamodb_client, table_item)


result = dynamodb_client.get_item(table_item)
puts "#{result.item['title']} (#{result.item['year'].to_i}):"
puts " Plot: #{result.item['info']['plot']}"
puts " Rating: #{result.item['info']['rating'].to_i}"
rescue StandardError => e
puts "Error getting movie '#{table_item[:key][:title]} " \
"(#{table_item[:key][:year]})': #{e.message}"
end

def run_me
region = 'us-west-2'
table_name = 'Movies'
title = 'The Big New Movie'
year = 2015

# To use the downloadable version of Amazon DynamoDB,


# uncomment the endpoint statement.
Aws.config.update(

Versión de API 2012-08-10


200
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

# endpoint: 'http://localhost:8000',
region: region
)

dynamodb_client = Aws::DynamoDB::Client.new

table_item = {
table_name: table_name,
key: {
year: year,
title: title
}
}

puts "Getting information about '#{title} (#{year})' " \


"from table '#{table_name}'..."
get_item_from_table(dynamodb_client, table_item)
end

run_me if $PROGRAM_NAME == __FILE__

2. Para ejecutar el programa, introduzca el siguiente comando.

ruby MoviesItemOps02.rb

Paso 3.3: Actualización de un elemento


Puede utilizar el método update_item para modificar un elemento existente. Puede actualizar los valores
de los atributos existentes, así como agregar atributos nuevos o eliminarlos.

En este ejemplo, se llevan a cabo las siguientes actualizaciones:

• Cambie el valor de los atributos existentes (rating, plot).


• Agregue un nuevo atributo de lista (actors) al mapa info existente.

A continuación se muestra el elemento existente.

{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Nothing happens at all.",
rating: 0
}
}

El elemento se actualiza como se indica a continuación.

{
year: 2015,
title: "The Big New Movie",
info: {
plot: "Everything happens all at once.",
rating: 5.5,
actors: ["Larry", "Moe", "Curly"]
}
}

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps03.rb.

Versión de API 2012-08-10


201
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

require 'aws-sdk-dynamodb'

def table_item_updated?(dynamodb_client, table_item)


response = dynamodb_client.update_item(table_item)
puts "Table item updated with the following attributes for 'info':"
response.attributes['info'].each do |key, value|
if key == 'rating'
puts "#{key}: #{value.to_f}"
else
puts "#{key}: #{value}"
end
end
true
rescue StandardError => e
puts "Error updating item: #{e.message}"
false
end

def run_me
region = 'us-west-2'
table_name = 'Movies'
title = 'The Big New Movie'
year = 2015

# To use the downloadable version of Amazon DynamoDB,


# uncomment the endpoint statement.
Aws.config.update(
# endpoint: 'http://localhost:8000',
region: region
)

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

puts "Updating table '#{table_name}' with information about " \


"'#{title} (#{year})'..."

if table_item_updated?(dynamodb_client, table_item)
puts 'Table updated.'
else
puts 'Table not updated.'
end
end

run_me if $PROGRAM_NAME == __FILE__

Versión de API 2012-08-10


202
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

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

Paso 3.4: Incremento de un contador atómico


DynamoDB es compatible con contadores atómicos, que utilizan elupdate_itemPara aumentar o reducir
el valor de un atributo sin interferir con otras solicitudes de escritura. Todas las solicitudes de escritura se
aplican en el orden en que se reciben.

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.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps04.rb.

require 'aws-sdk-dynamodb'

def table_item_updated?(dynamodb_client, table_item)


result = dynamodb_client.update_item(table_item)
puts "Table item updated with the following attributes for 'info':"
result.attributes['info'].each do |key, value|
if key == 'rating'
puts "#{key}: #{value.to_f}"
else
puts "#{key}: #{value}"
end
end
true
rescue StandardError => e
puts "Error updating item: #{e.message}"
false
end

def run_me
region = 'us-west-2'
table_name = 'Movies'
title = 'The Big New Movie'
year = 2015

# To use the downloadable version of Amazon DynamoDB,


# uncomment the endpoint statement.
Aws.config.update(
# endpoint: 'http://localhost:8000',
region: region
)

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

Versión de API 2012-08-10


203
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

expression_attribute_values: {
':val': 1
},
return_values: 'UPDATED_NEW'
}

puts "Updating table '#{table_name}' with information about " \


"'#{title} (#{year})'..."

if table_item_updated?(dynamodb_client, table_item)
puts 'Table updated.'
else
puts 'Table not updated.'
end
end

run_me if $PROGRAM_NAME == __FILE__

2. Para ejecutar el programa, introduzca el siguiente comando.

ruby MoviesItemOps04.rb

Paso 3.5: Actualización de un elemento (condicionalmente)


El programa siguiente muestra cómo usar update_item con una condición. Si la condición se evalúa
en true (verdadero), la actualización se lleva a cabo correctamente; de lo contrario, la actualización no se
realiza.

En este caso, el elemento se actualiza solamente si el número de actores es mayor que tres.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps05.rb.

require 'aws-sdk-dynamodb'

def table_item_updated?(dynamodb_client, table_item)


result = dynamodb_client.update_item(table_item)
puts "Table item updated with the following attributes for 'info':"
result.attributes['info'].each do |key, value|
if key == 'rating'
puts "#{key}: #{value.to_f}"
else
puts "#{key}: #{value}"
end
end
true
rescue StandardError => e
puts "Error updating item: #{e.message}"
false
end

def run_me
region = 'us-west-2'
table_name = 'Movies'
title = 'The Big New Movie'
year = 2015

# To use the downloadable version of Amazon DynamoDB,


# uncomment the endpoint statement.
Aws.config.update(
# endpoint: 'http://localhost:8000',
region: region
)

Versión de API 2012-08-10


204
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

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

puts "Updating table '#{table_name}' with information about " \


"'#{title} (#{year})'..."

if table_item_updated?(dynamodb_client, table_item)
puts 'Table updated.'
else
puts 'Table not updated.'
end
end

run_me if $PROGRAM_NAME == __FILE__

2. Para ejecutar el programa, introduzca el siguiente comando.

ruby MoviesItemOps05.rb

Debe producirse un error en el programa y mostrar el mensaje siguiente.

The conditional request failed (Error en la solicitud condicional)

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.

condition_expression: "size(info.actors) >= :num",

Ahora, la condición es mayor o igual que 3 en lugar de mayor que 3.


4. Ejecute el programa de nuevo. Ahora, el método update_item debería realizarse correctamente.

Paso 3.6: Eliminación de un elemento


Puede utilizar el método delete_item para eliminar un elemento especificando su clave principal.
También puede incluir una instrucción condition_expression para evitar que se elimine el elemento si
no se cumple la condición.

En el siguiente ejemplo, se intenta eliminar un elemento de película determinado si su calificación es igual


o menor que 5.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesItemOps06.rb.

require 'aws-sdk-dynamodb'

def table_item_deleted?(dynamodb_client, table_item)


dynamodb_client.delete_item(table_item)

Versión de API 2012-08-10


205
Amazon DynamoDB Guía para desarrolladores
Paso 3: Creación, lectura, actualización
y eliminación de elementos

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

# To use the downloadable version of Amazon DynamoDB,


# uncomment the endpoint statement.
Aws.config.update(
# endpoint: 'http://localhost:8000',
region: region
)

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

puts "Deleting item from table '#{table_name}' matching " \


"'#{title} (#{year})' if specified criteria are met..."

if table_item_deleted?(dynamodb_client, table_item)
puts 'Item deleted.'
else
puts 'Item not deleted.'
end
end

run_me if $PROGRAM_NAME == __FILE__

2. Para ejecutar el programa, introduzca el siguiente comando.

ruby MoviesItemOps06.rb

Debe producirse un error en el programa y mostrar el mensaje siguiente.

The conditional request failed (Error en la solicitud condicional)

El programa falla porque la calificación de esta película concreta es mayor que 5.


3. Modifique el programa para eliminar la condición.

params = {
table_name: "Movies",
key: {
year: year,
title: title
}
}

Versión de API 2012-08-10


206
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

4. Ejecute el programa. Ahora, la eliminación se llevará a cabo correctamente porque se ha eliminado la


condición.

Paso 4: Consulta y examen de los datos


Puede utilizar el método query para recuperar datos de una tabla. Debe especificar un valor de clave de
partición. La clave de ordenación es opcional.

La clave principal de la tabla Movies consta de:

• year: clave de partición. El tipo de atributo es number. 


• title: clave de ordenación. El tipo de atributo es string.

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)

Paso 4.1: Consulta de todas las películas estrenadas durante un


año
El programa siguiente recupera todas las películas estrenadas en el año (year) 1985.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesQuery01.rb.

require 'aws-sdk-dynamodb'

def query_for_items_from_table(dynamodb_client, query_condition)


# To display the elapsed time for the query operation,
# uncomment the following three comments.
# start = Time.now
result = dynamodb_client.query(query_condition)
# finish = Time.now
# puts "Search took #{finish - start} seconds."
if result.items.count.zero?
puts 'No matching movies found.'
else
puts "Found #{result.items.count} matching movies:"
result.items.each do |movie|
puts "#{movie['title']} (#{movie['year'].to_i})"
end
end
rescue StandardError => e
puts "Error querying for table items: #{e.message}"

Versión de API 2012-08-10


207
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

end

def run_me
region = 'us-west-2'
table_name = 'Movies'
year = 1985

# To use the downloadable version of Amazon DynamoDB,


# uncomment the endpoint statement.
Aws.config.update(
# endpoint: 'http://localhost:8000',
region: region
)

dynamodb_client = Aws::DynamoDB::Client.new

# To query on the 'title' range/sort key in addition to the 'year'


# hash/partition key, uncomment the following three 'title' comments.
query_condition = {
table_name: table_name,
key_condition_expression: '#yr = :yyyy', # '#yr = :yyyy AND #t = :title'
expression_attribute_names: {
# '#t' => 'title',
'#yr' => 'year'
},
expression_attribute_values: {
# ':title' => 'After Hours',
':yyyy' => year
}
}

puts "Searching for items in the '#{table_name}' table from '#{year}'..."

query_for_items_from_table(dynamodb_client, query_condition)
end

run_me if $PROGRAM_NAME == __FILE__

Note

• expression_attribute_names permite sustituir nombres. Usamos esto porqueyeares


una palabra reservada en Amazon DynamoDB. No puede usarlo directamente en ninguna
expresión, incluida KeyConditionExpression. Puede usar el nombre de atributo de
expresión #yr para solucionar el problema.
• expression_attribute_values permite sustituir valores. Lo utilizamos porque no se
pueden utilizar literales en ninguna expresión, incluida key_condition_expression.
Puede usar el valor de atributo de expresión :yyyy para solucionar el problema.
2. Para ejecutar el programa, introduzca el siguiente comando.

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

Versión de API 2012-08-10


208
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

Paso 4.2: Consulta de todas las películas estrenadas durante un


año con unos títulos determinados
El programa siguiente recupera todas las películas estrenadas enyear1992 con untitleA partir de la
«A» a la «L».

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesQuery02.rb.

require 'aws-sdk-dynamodb'

def query_for_items_from_table(dynamodb_client, query_condition)


# To display the elapsed time for the query operation,
# uncomment the following three comments.
# start = Time.now
result = dynamodb_client.query(query_condition)
# finish = Time.now
# puts "Search took #{finish - start} seconds."
if result.items.count.zero?
puts 'No matching movies found.'
else
puts "Found #{result.items.count} matching movies:"
result.items.each do |movie|
puts "#{movie['title']} (#{movie['year'].to_i}):"
if movie['info'].key?('genres') && movie['info']['genres'].count.positive?
puts ' Genres:'
movie['info']['genres'].each do |genre|
puts " #{genre}"
end
end
if movie['info'].key?('actors') && movie['info']['actors'].count.positive?
puts ' Actors:'
movie['info']['actors'].each do |actor|
puts " #{actor}"
end
end
end
end
rescue StandardError => e
puts "Error querying for table items: #{e.message}"
end

def run_me
region = 'us-west-2'
table_name = 'Movies'
year = 1982
letter1 = 'A'
letter2 = 'L'

# To use the downloadable version of Amazon DynamoDB,


# uncomment the endpoint statement.
Aws.config.update(
# endpoint: 'http://localhost:8000',
region: region
)

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: {

Versión de API 2012-08-10


209
Amazon DynamoDB Guía para desarrolladores
Paso 4: Consulta y examen de los datos

':yyyy' => year,


':letter1' => letter1,
':letter2' => letter2
}
}

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

run_me if $PROGRAM_NAME == __FILE__

2. Para ejecutar el programa, introduzca el siguiente comando.

ruby MoviesQuery02.rb

Paso 4.3: Examen


El método scan lee cada uno de los elementos de la tabla y devuelve todos los datos de la tabla. Puede
proporcionar una expresión filter_expression opcional para que solamente se devuelvan los
elementos que coinciden con los criterios. No obstante, tenga en cuenta que el filtro solo se aplica después
de haber examinado toda la tabla.

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.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesScan.rb.

require 'aws-sdk-dynamodb'

def scan_for_items_from_table(dynamodb_client, scan_condition)


# To display the elapsed time for the query operation,
# uncomment the following three comments.
#start = Time.now
loop do
result = dynamodb_client.scan(scan_condition)

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?

puts "Searching for more movies..."


scan_condition[:exclusive_start_key] = result.last_evaluated_key
end
end
puts 'Finished searching.'
# finish = Time.now
# puts "Search took #{finish - start} seconds."
rescue StandardError => e
puts "Error scanning for table items: #{e.message}"
end

Versión de API 2012-08-10


210
Amazon DynamoDB Guía para desarrolladores
Paso 5: (Opcional) Eliminar la tabla

def run_me
region = 'us-west-2'
table_name = 'Movies'
start_year = 1950
end_year = 1959

# To use the downloadable version of Amazon DynamoDB,


# uncomment the endpoint statement.
Aws.config.update(
# endpoint: 'http://localhost:8000',
region: region
)

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

run_me if $PROGRAM_NAME == __FILE__

En el código, observe lo siguiente:

• projection_expression especifica los atributos que se desea obtener en el resultado del


examen.
• filter_expression especifica una condición que devuelve solamente los elementos que
cumplen la condición. Todos los demás elementos se descartan.
2. Para ejecutar el programa, introduzca el siguiente comando.

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

Paso 5: (Opcional) Eliminar la tabla


Siga estos pasos para eliminar elMoviesTabla de.

1. Copie el siguiente programa y péguelo en un archivo llamado MoviesDeleteTable.rb.

require 'aws-sdk-dynamodb'

def table_deleted?(dynamodb_client, table_name)


dynamodb_client.delete_table(table_name: table_name)

Versión de API 2012-08-10


211
Amazon DynamoDB Guía para desarrolladores
Summary

true
rescue StandardError => e
puts "Error deleting table: #{e.message}"
false
end

def run_me
region = 'us-west-2'
table_name = 'Movies'

# To use the downloadable version of Amazon DynamoDB,


# uncomment the endpoint statement.
Aws.config.update(
# endpoint: 'http://localhost:8000',
region: region
)

dynamodb_client = Aws::DynamoDB::Client.new

puts "Deleting table '#{table_name}'..."

if table_deleted?(dynamodb_client, table_name)
puts 'Table deleted.'
else
puts 'Table not deleted.'
end
end

run_me if $PROGRAM_NAME == __FILE__

2. Para ejecutar el programa, introduzca el siguiente comando.

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.

Modificación del código para utilizar el servicio de DynamoDB


Debe cambiar el punto de enlace en la aplicación para usar el servicio de DynamoDB. Para ello, busque
las siguientes líneas en el código.

Aws.config.update({
region: "us-west-2",
endpoint: "http://localhost:8000"
})

Elimine elendpointpara que el código tenga el aspecto siguiente.

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.

Versión de API 2012-08-10


212
Amazon DynamoDB Guía para desarrolladores
Summary

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.

Versión de API 2012-08-10


213
Amazon DynamoDB Guía para desarrolladores
Información general deAWSSupport
del SDK de con DynamoDB

Programación con DynamoDB y


elAWSSDK de
En esta sección se tratan los temas relacionados con los desarrolladores. Si lo que desea es
ejecutar ejemplos de código, consulteCómo ejecutar los ejemplos de código de esta guía para
desarrolladores (p. 332).
Note

En diciembre de 2017,AWScomenzó el proceso de migración de todos los endpoints de Amazon


DynamoDB para utilizar certificados seguros emitidos por Amazon Trust Services (ATS). Para
obtener más información, consulte Solución de problemas de establecimiento de conexiones SSL/
TLS de (p. 1078).

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)

Información general deAWSSupport del SDK de


con DynamoDB
En el siguiente diagrama se ofrece información general sobre la programación de aplicaciones de Amazon
DynamoDB utilizando elAWSSDK de.

Versión de API 2012-08-10


214
Amazon DynamoDB Guía para desarrolladores
Información general deAWSSupport
del SDK de con DynamoDB

1. Puede escribir una aplicación utilizando unAWSSDK para su lenguaje de programación.


2. EACHAWSEl SDK proporciona una o varias interfaces de programación para trabajar con DynamoDB.
Las interfaces específicas disponibles dependerán de qué lenguaje de programación yAWSSDK que
usa.
3. LaAWSEl SDK construye de solicitudes HTTP (S) para usarlas con el API de bajo nivel de DynamoDB.
4. LaAWSEl SDK envía la solicitud al punto de enlace de DynamoDB.
5. DynamoDB ejecuta la solicitud. Si la solicitud se realiza correctamente, DynamoDB devuelve un código
de respuesta HTTP 200 (OK). Si la solicitud no se puede realizar, DynamoDB devuelve un código de
error HTTP y un mensaje de error.
6. LaAWSEl SDK procesa la respuesta y se la transmite a la aplicación.

Cada una de lasAWSLos SDK proporcionan servicios importantes a la aplicación, tales como los
siguientes:

• Formatear las solicitudes HTTP(S) y serializar los parámetros de solicitud.


• Generar una firma criptográfica de cada solicitud.

Versión de API 2012-08-10


215
Amazon DynamoDB Guía para desarrolladores
Interfaces de programación

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

No es necesario escribir código para ninguna de estas tareas.


Note
Para obtener más información acerca deAWSConsulte los SDK, incluidas las instrucciones de
instalación y la documentación,Herramientas para Amazon Web Services.

Interfaces de programación

EVERYAWSSDKproporciona una o varias interfaces de programación para trabajar con Amazon


DynamoDB. Estas interfaces abarcan desde sencillos encapsuladores de bajo nivel de DynamoDB hasta
capas de persistencia orientadas a objetos. Las interfaces disponibles varían en función de laAWSSDK y
lenguaje de programación que se utilice.

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

Versión de API 2012-08-10


216
Amazon DynamoDB Guía para desarrolladores
Interfaces de bajo nivel

Temas
• Interfaces de bajo nivel (p. 217)
• Interfaces de documentos (p. 218)
• Interfaz de persistencia de objetos (p. 218)

Interfaces de bajo nivel


EACHAWSEl SDK proporciona una interfaz de bajo nivel para Amazon DynamoDB, con métodos que
imitan del modo más parecido posible las solicitudes del API de bajo nivel de DynamoDB.

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.

Lacom.amazonaws.services.dynamodbv2.AmazonDynamoDBLa clase implementa la interfaz de bajo


nivel de DynamoDB.

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;

public class MusicLowLevelDemo {

public static void main(String[] args) {

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();

HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();


key.put("Artist", new AttributeValue().withS("No One You Know"));
key.put("SongTitle", new AttributeValue().withS("Call Me Today"));

GetItemRequest request = new GetItemRequest()


.withTableName("Music")
.withKey(key);

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

Versión de API 2012-08-10


217
Amazon DynamoDB Guía para desarrolladores
Interfaces de documentos

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

Las interfaces de documentos están disponibles en laAWSSDK paraJava,.NET,Node.js,


yJavaScript en el navegador.

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.

Lacom.amazonaws.services.dynamodbv2.document.DynamoDBLa clase implementa la interfaz de


documentos de DynamoDB. Observe que DynamoDB actúa como encapsulador en torno al cliente de bajo
nivel (AmazonDynamoDB).

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;

public class MusicDocumentDemo {

public static void main(String[] args) {

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB docClient = new DynamoDB(client);

Table table = docClient.getTable("Music");


GetItemOutcome outcome = table.getItemOutcome(
"Artist", "No One You Know",
"SongTitle", "Call Me Today");

int year = outcome.getItem().getInt("Year");


System.out.println("The song was released in " + year);

}
}

Interfaz de persistencia de objetos


AlgunoAWSLos SDK proporcionan una interfaz de persistencia de objetos en la que no se llevan a cabo
directamente operaciones del plano de datos. En lugar de ello, se crean objetos que representan los
elementos de las tablas y los índices de Amazon DynamoDB y únicamente se interacciona con estos
objetos. Esto le permite escribir código orientado a objetos, en lugar de código orientado a bases de datos.
Note

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

Versión de API 2012-08-10


218
Amazon DynamoDB Guía para desarrolladores
Interfaz de persistencia de objetos

En el siguiente programa de Java se utiliza la interfaz de persistencia de objetos DynamoDBMapper del


AWS SDK for Java. LaMusicItemLa clase representa un elemento de laMusicTabla de.

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.

Lacom.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapperLa clase implementa


la interfaz de persistencia de objetos de DynamoDB. Observe que DynamoDBMapper actúa como
encapsulador en torno al cliente de bajo nivel (AmazonDynamoDB).

package com.amazonaws.codesamples;

import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapper;

public class MusicMapperDemo {

public static void main(String[] args) {

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();

DynamoDBMapper mapper = new DynamoDBMapper(client);

MusicItem keySchema = new MusicItem();


keySchema.setArtist("No One You Know");
keySchema.setSongTitle("Call Me Today");

try {
MusicItem result = mapper.load(keySchema);
if (result != null) {

Versión de API 2012-08-10


219
Amazon DynamoDB Guía para desarrolladores
API de bajo nivel

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

API de bajo nivel de DynamoDB


Temas
• Formato de las solicitudes (p. 222)
• Formato de respuesta (p. 222)
• Descriptores de tipos de datos (p. 223)
• Datos numéricos (p. 224)
• Datos de tipo Binary (p. 224)

Versión de API 2012-08-10


220
Amazon DynamoDB Guía para desarrolladores
API de bajo nivel

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

Versión de API 2012-08-10


221
Amazon DynamoDB Guía para desarrolladores
Formato de las solicitudes

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.

Formato de las solicitudes


El API de bajo nivel de DynamoDB acepta HTTP (S)POSTcomo entrada. LaAWSLos SDK construyen estas
solicitudes para usted.

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"}
}
}

Tenga en cuenta lo siguiente en relación con esta solicitud:

• LaAuthorizationcontiene la información necesaria para que DynamoDB autentique la solicitud. Para


obtener más información, consulteFirmaAWSSolicitudes API deyProceso de firma Signature Version 4en
laReferencia general de Amazon Web Services Services.
• LaX-Amz-Targetcontiene el nombre de una operación de DynamoDB: GetItem. Además, va
acompañada de la versión del API de bajo nivel, en este caso,20120810.)
• La carga (cuerpo) de la solicitud contiene los parámetros de la operación, en formato JSON. En la
operación GetItem, los parámetros son TableName y Key.

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

Versión de API 2012-08-10


222
Amazon DynamoDB Guía para desarrolladores
Descriptores de tipos de datos

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

Descriptores de tipos de datos


El protocolo del API de bajo nivel de DynamoDB requiere que cada atributo vaya acompañado de un
descriptor del tipo de datos. Descriptores de tipos de datosson tokens que indican a DynamoDB cómo
interpretar cada atributo.

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

A continuación se muestra una lista completa de descriptores de tipos de datos de DynamoDB:

• S: String
• N: Number
• B: Binary
• BOOL: Boolean
• NULL: Null

Versión de API 2012-08-10


223
Amazon DynamoDB Guía para desarrolladores
Datos numéricos

• M: Map
• L: List
• SS: String Set
• NS: Number Set
• BS: Binary Set

Note

Para obtener descripciones detalladas de los tipos de datos de DynamoDB, consulteTipos de


datos (p. 14).

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.

Datos de tipo Binary


DynamoDB los atributos binarios. Sin embargo, JSON no presenta compatibilidad nativa con la codificación
de datos binarios. Para enviar datos binarios en una solicitud, es preciso codificarlos en formato base64. Al
recibir la solicitud, DynamoDB decodifica los datos base64 para que vuelvan a ser binarios.

El esquema de codificación base64 utilizado por DynamoDB se describe enRFC 4648En el sitio web de
Internet Engineering Task Force (IETF).

Control de errores con DynamoDB


En esta sección se describen los errores de tiempo de ejecución y se explica cómo controlarlos. También
se describen los mensajes y códigos de error específicos de Amazon DynamoDB.

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)

Versión de API 2012-08-10


224
Amazon DynamoDB Guía para desarrolladores
Componentes de un error

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:

• Un código de estado HTTP (por ejemplo, 400).


• Un nombre de excepción (por ejemplo, ResourceNotFoundException).
• Un mensaje de error (por ejemplo, Requested resource not found: Table: tablename not
found).

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.

HTTP/1.1 400 Bad Request


x-amzn-RequestId: LDM6CJP8RMQ1FHKSC1RBVJFPNVV4KQNSO5AEMF66Q9ASUAAJG
Content-Type: application/x-amz-json-1.0
Content-Length: 240
Date: Thu, 15 Mar 2012 23:56:23 GMT

{"__type":"com.amazonaws.dynamodb.v20120810#ResourceNotFoundException",
"message":"Requested resource not found: Table: tablename not found"}

Mensajes y códigos de error


A continuación se muestra una lista de excepciones devueltas por DynamoDB, agrupados por su código
de estado HTTP. Si ¿Reintentar? es Sí, puede volver a enviar la misma solicitud. Si ¿Reintentar? es No,
debe corregir el problema en el lado del cliente antes de volver a enviar la solicitud.

Código de estado HTTP 400


El código de estado HTTP 400 indica que existe un problema en la solicitud; por ejemplo, se ha producido
un error de autenticación, faltan parámetros obligatorios o se ha superado el rendimiento aprovisionado de
una tabla. Debe corregir el problema en la aplicación antes de volver a enviar la solicitud.

AccessDeniedException

Mensaje: Acceso denegado.

El cliente no firmó correctamente la solicitud. Si utiliza unaAWSSDK, las solicitudes se


firman automáticamente; en caso contrario, visite laProceso de firma Signature Version 4en
laAWSReferencia general de.

¿Reintentar? No

ConditionalCheckFailedException

Mensaje: The conditional request failed.

Versión de API 2012-08-10


225
Amazon DynamoDB Guía para desarrolladores
Mensajes y códigos de error

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

Mensaje: The request signature does not conform toAWSNormas.

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

Mensaje: Tamaño de colección superado.

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

Mensaje: Demasiadas operaciones para un determinado suscriptor.

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

Mensaje: The request must contain a valid (registered)AWSAccess Key ID.

La solicitud no incluía el encabezado de autorización necesario o el formato de este último era


incorrecto. Consulte API de bajo nivel de DynamoDB (p. 220).

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

Versión de API 2012-08-10


226
Amazon DynamoDB Guía para desarrolladores
Mensajes y códigos de error

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

Ejemplo: La velocidad de solicitudes bajo demanda supera el rendimiento de la cuenta.

¿Reintentar? Sí

ResourceInUseException

Mensaje: El recurso que intenta cambiar está en uso.

Ejemplo: Ha intentado volver a crear una tabla que ya existía o eliminar una tabla que se encuentra en
elCREATINGestado.

¿Reintentar? No

ResourceNotFoundException

Mensaje: No se encuentra el recurso solicitado.

Ejemplo: La tabla que se ha solicitado no existe o se encuentra demasiado al principio de


laCREATINGestado.

¿Reintentar? No

ThrottlingException

Mensaje: Rate of requests exceeds the allowed throughput.

Esta excepción se devuelve como respuesta de AmazonServiceException con un código de estado


THROTTLING_EXCEPTION. Esta excepción es posible que se produzca si realiza operaciones de la
API de plano de control con demasiada rapidez.

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

Mensaje: El ID de clave de acceso o el token de seguridad no es válido.

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

Mensaje: Varía, según el error concreto de que se trate.

Versión de API 2012-08-10


227
Amazon DynamoDB Guía para desarrolladores
Control de errores en la aplicación

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

Código de estado HTTP 5xx


Un código de estado HTTP 5xx indica un problema cuya resolución corresponde a AWS. Puede ser un
error transitorio, en cuyo caso puede reintentar la solicitud hasta que se ejecute satisfactoriamente. De lo
contrario, vaya a laAWSService Health DashboardPara comprobar si existe algún problema funcional con
el servicio.

Internal Server Error (HTTP 500)

DynamoDB no pudo procesar la solicitud.

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

Service Unavailable (HTTP 503)

DynamoDB no está disponible en este momento. Debería tratarse de un estado temporal.

¿Reintentar? Sí

Control de errores en la aplicación


Para que la aplicación funcione sin problemas, es preciso agregar lógica que capture los errores y
responda a ellos. Los enfoques habituales incluyen el uso de bloques try-catch o instrucciones if-
then.

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.

Table table = dynamoDB.getTable("Movies");

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");
}

Versión de API 2012-08-10


228
Amazon DynamoDB Guía para desarrolladores
Reintentos de error y retardo exponencial

} catch (AmazonServiceException ase) {


System.err.println("Could not complete operation");
System.err.println("Error Message: " + ase.getMessage());
System.err.println("HTTP Status: " + ase.getStatusCode());
System.err.println("AWS Error Code: " + ase.getErrorCode());
System.err.println("Error Type: " + ase.getErrorType());
System.err.println("Request ID: " + ase.getRequestId());

} catch (AmazonClientException ace) {


System.err.println("Internal error occurred communicating with DynamoDB");
System.out.println("Error Message: " + ace.getMessage());
}

En este ejemplo de código, la construcción try-catch controla dos tipos de excepciones diferentes:

• AmazonServiceException: se genera si la solicitud del cliente se ha transmitido correctamente a


DynamoDB, pero DynamoDB no ha podido procesarla y ha devuelto una respuesta de error.
• AmazonClientException: se genera si el cliente no ha podido obtener una respuesta de un servicio o
sí la ha obtenido pero no ha podido analizarla.

Reintentos de error y retardo exponencial


Numerosos componentes de una red, como los servidores DNS, los conmutadores o los balanceadores de
carga, entre otros, pueden generar errores en cualquier punto de la vida de una solicitud determinada. La
técnica habitual para abordar estas respuestas de error en un entorno de red consiste en implementar los
reintentos en la aplicación cliente. Esta técnica aumenta la fiabilidad de la aplicación.

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

LaAWSLos SDK de implementan una lógica de reintento automático y retardo exponencial.

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.

Versión de API 2012-08-10


229
Amazon DynamoDB Guía para desarrolladores
Operaciones por lotes y control de errores

Operaciones por lotes y control de errores


El API de bajo nivel de DynamoDB admite las operaciones por lotes de lectura y
escritura.BatchGetItemlee elementos de una o varias tablas, yBatchWriteItempone o elimina
elementos en una o varias tablas. Estas operaciones por lotes se implementan como encapsuladores en
torno a otras operaciones de DynamoDB que no son por lotes. Es decir, BatchGetItem invoca GetItem
una vez para cada elemento del lote. De igual forma,BatchWriteItem invoca DeleteItem o PutItem,
según proceda, para cada elemento del lote.

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.

Interfaces de programación de nivel superior para


DynamoDB
LaAWSLos SDK proporcionan aplicaciones con interfaces de bajo nivel para trabajar con Amazon
DynamoDB. Estas clases y métodos del lado del cliente se corresponden directamente con los API
DynamoDB de bajo nivel de DynamoDB. Sin embargo, muchos desarrolladores experimentan una
sensación de desconexión, oImpedancia no coincidenteCuando tienen que mapear tipos de datos
complejos a los elementos de una tabla de base de datos. Con una interfaz de bajo nivel de base de datos,
los desarrolladores deben escribir métodos para leer o escribir datos de objetos en tablas de base de
datos, y viceversa. La cantidad de código adicional necesaria para cada combinación de tipo de objeto y
tabla de base de datos puede resultar abrumadora.

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.

Versión de API 2012-08-10


230
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

Java

• Java: DynamoDBMapper (p. 231)

.NET

• .NET: Modelo de documento (p. 279)


• .NET: Modelo de persistencia de objetos (p. 303)

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

La clase DynamoDBMapper no permite crear, actualizar o eliminar tablas. Para realizar


estas tareas, utilice la interfaz del SDK de bajo nivel del Java en su lugar. Para obtener más
información, consulte Uso de tablas de DynamoDB en Java (p. 398).

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;

Versión de API 2012-08-10


231
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBIgnore;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTable;

@DynamoDBTable(tableName="ProductCatalog")
public class CatalogItem {

private Integer id;


private String title;
private String ISBN;
private Set<String> bookAuthors;
private String someProp;

@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; }
}

En el código anterior, la anotación @DynamoDBTable mapea la clase CatalogItem a la tabla


ProductCatalog. Puede almacenar instancias de clases individuales como los elementos de la tabla. En
la definición de clase, la anotación @DynamoDBHashKey mapea la propiedad Id a la clave principal.

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@DynamoDBAttributeLa anotación es opcional cuando el nombre del atributo de DynamoDB


coincide con el nombre de la propiedad declarada en la clase. Si son distintos, use esta anotación con
laattributeName()Para especificar qué atributo DynamoDB se corresponde con esta propiedad.

En el ejemplo anterior, la anotación @DynamoDBAttribute se agrega a cada propiedad para asegurarse


de que los nombres de las propiedades coincidan exactamente con las tablas creadas en Creación de
tablas y carga de datos para ejemplos de código en DynamoDB (p. 333) y para guardar la coherencia
con los nombres de atributos utilizados en otros ejemplos de código de esta guía.

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.

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();

Versión de API 2012-08-10


232
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

DynamoDBMapper mapper = new DynamoDBMapper(client);

CatalogItem item = new CatalogItem();


item.setId(102);
item.setTitle("Book 102 Title");
item.setISBN("222-2222222222");
item.setBookAuthors(new HashSet<String>(Arrays.asList("Author 1", "Author 2")));
item.setSomeProp("Test");

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.

CatalogItem partitionKey = new CatalogItem();

partitionKey.setId(102);
DynamoDBQueryExpression<CatalogItem> queryExpression = new
DynamoDBQueryExpression<CatalogItem>()
.withHashKeyValues(partitionKey);

List<CatalogItem> itemList = mapper.query(CatalogItem.class, queryExpression);

for (int i = 0; i < itemList.size(); i++) {


System.out.println(itemList.get(i).getTitle());
System.out.println(itemList.get(i).getBookAuthors());
}

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.

Tipos de datos admitidos


En esta sección se describen los tipos de datos arbitrarios, las colecciones y los tipos de datos de Java
primitivos compatibles en Amazon DynamoDB.

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.

Versión de API 2012-08-10


233
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

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

DynamoDB es compatible con JavaEstablezca,List, yMapTipos de colección. En la tabla siguiente se


resume el mapeo de estos tipos de Java a los tipos de DynamoDB.

Tipo de Java Tipo DynamoDB

Todos los tipos de números N (tipo Number)

Strings S (tipo String)

Booleano BOOL (tipo booleano), 0 o 1.

ByteBuffer B (tipo Binary)

Fecha S (tipo String). Los valores Date se almacenan


como cadenas con formato ISO-8601.

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

Anotaciones de Java para DynamoDB


En esta sección se describen las anotaciones que están disponibles para mapear las clases y las
propiedades a las tablas y los atributos de Amazon DynamoDB.

Para obtener la documentación de Javadoc correspondiente, consulte,Resumen de tipos de anotaciónen


laAWS SDK for JavaReferencia de la API.
Note

En las anotaciones siguientes, solo son obligatorias DynamoDBTable y DynamoDBHashKey.

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)

Versión de API 2012-08-10


234
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

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; }

DynamoDBMapper utiliza Authors como nombre de atributo al guardar el objeto en la tabla.

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.

El siguiente ejemplo muestra el uso de 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; }

public static void saveItem() {


AutoGeneratedKeys obj = new AutoGeneratedKeys();
obj.setPayload("abc123");

// id field is null at this point


DynamoDBMapper mapper = new DynamoDBMapper(dynamoDBClient);
mapper.save(obj);

System.out.println("Object was saved with id " + obj.getId());


}
}

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.

public class ProductCatalogItem {

private Integer id; //partition key


private Pictures pictures;
/* ...other attributes omitted... */

Versión de API 2012-08-10


235
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

@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;}

// Additional properties go here.

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

ProductCatalogItem item = new ProductCatalogItem();

Pictures pix = new Pictures();


pix.setFrontView("http://example.com/products/123_front.jpg");
pix.setRearView("http://example.com/products/123_rear.jpg");
pix.setSideView("http://example.com/products/123_left_side.jpg");
item.setPictures(pix);

item.setId(123);

mapper.save(item);

El elemento ProductCatalog resultante tendría este aspecto (en formato JSON).

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

Versión de API 2012-08-10


236
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

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.

Versión de API 2012-08-10


237
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

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; }

// Additional properties go here.


}

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.

Versión de API 2012-08-10


238
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

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

LaDynamoDBMapperLa clase es el punto de entrada a Amazon DynamoDB. Proporciona acceso a un


punto de enlace de DynamoDB y le permite obtener acceso a sus datos en diversas tablas. También
permite realizar varias operaciones de creación, lectura, actualización y eliminación (CRUD, Create,
Read, Update y Delete) en elementos y ejecutar consultas y análisis en tablas. Esta clase proporciona los
siguientes métodos para trabajar con DynamoDB.

Para obtener la documentación de Javadoc correspondiente, consulte,DynamoDBMapperen laAWS SDK


for JavaReferencia de la API.

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

Versión de API 2012-08-10


239
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

de versión o se genera una clave, el objeto que se ha pasado se actualiza como consecuencia de la
operación.

De forma predeterminada, solo se actualizan los atributos correspondientes a propiedades de clases


mapeadas. Ningún atributo existente adicional de un elemento se ve afectado. Sin embargo, si especifica
SaveBehavior.CLOBBER, puede forzar que se sobrescriba el elemento completo.

mapper.save(obj, new DynamoDBMapperConfig(DynamoDBMapperConfig.SaveBehavior.CLOBBER));

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.

CatalogItem item = mapper.load(CatalogItem.class, item.getId(),


new DynamoDBMapperConfig(DynamoDBMapperConfig.ConsistentReads.CONSISTENT));

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.

Reply ( Id, ReplyDateTime, ... )

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.

Versión de API 2012-08-10


240
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

Example

String forumName = "&DDB;";


String forumSubject = "&DDB; Thread 1";
String partitionKey = forumName + "#" + forumSubject;

long twoWeeksAgoMilli = (new Date()).getTime() - (14L*24L*60L*60L*1000L);


Date twoWeeksAgo = new Date();
twoWeeksAgo.setTime(twoWeeksAgoMilli);
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
String twoWeeksAgoStr = df.format(twoWeeksAgo);

Map<String, AttributeValue> eav = new HashMap<String, AttributeValue>();


eav.put(":v1", new AttributeValue().withS(partitionKey));
eav.put(":v2",new AttributeValue().withS(twoWeeksAgoStr.toString()));

DynamoDBQueryExpression<Reply> queryExpression = new DynamoDBQueryExpression<Reply>()


.withKeyConditionExpression("Id = :v1 and ReplyDateTime > :v2")
.withExpressionAttributeValues(eav);

List<Reply> latestReplies = mapper.query(Reply.class, queryExpression);

La consulta devuelve una colección de objetos Reply.

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; }

// Additional properties go here.


}

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é

Versión de API 2012-08-10


241
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

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

HashMap<String, AttributeValue> eav = new HashMap<String, AttributeValue>();


eav.put(":v1", new AttributeValue().withS("User A"));
eav.put(":v2", new AttributeValue().withS("DynamoDB"));

DynamoDBQueryExpression<PostedByMessage> queryExpression = new


DynamoDBQueryExpression<PostedByMessage>()
.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false)
.withKeyConditionExpression("PostedBy = :v1 and begins_with(Message, :v2)")
.withExpressionAttributeValues(eav);

List<PostedByMessage> iList = mapper.query(PostedByMessage.class, queryExpression);

La consulta devuelve una colección de objetos PostedByMessage.

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.

Reply ( Id, ReplyDateTime, ... )

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

HashMap<String, AttributeValue> eav = new HashMap<String, AttributeValue>();


eav.put(":v1", new AttributeValue().withS("2015"));

DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()


.withFilterExpression("begins_with(ReplyDateTime,:v1)")
.withExpressionAttributeValues(eav);

List<Reply> replies = mapper.scan(Reply.class, scanExpression);

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.

Versión de API 2012-08-10


242
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

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.

En el siguiente ejemplo de código se examina PostedBy-Message-Index. No se utiliza ningún filtro de


examen, por lo que se devuelven todos los elementos del índice.

DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()


.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false);

List<PostedByMessage> iList = mapper.scan(PostedByMessage.class, scanExpression);


Iterator<PostedByMessage> indexItems = iList.iterator();

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.

En el siguiente ejemplo de código Java se realiza un examen paralelo de la tabla Product.

int numberOfThreads = 4;

Map<String, AttributeValue> eav = new HashMap<String, AttributeValue>();


eav.put(":n", new AttributeValue().withN("100"));

DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()


.withFilterExpression("Price <= :n")
.withExpressionAttributeValues(eav);

List<Product> scanResult = mapper.parallelScan(Product.class, scanExpression,


numberOfThreads);

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.

En el siguiente código Java se guardan dos elementos (libros) en la tabla ProductCatalog.

Book book1 = new Book();

Versión de API 2012-08-10


243
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

book1.id = 901;
book1.productCategory = "Book";
book1.title = "Book 901 Title";

Book book2 = new Book();


book2.id = 902;
book2.productCategory = "Book";
book2.title = "Book 902 Title";

mapper.batchSave(Arrays.asList(book1, book2));

batchLoad
Recupera varios elementos de una o varias tablas mediante sus claves principales.

En el siguiente código Java se recuperan dos elementos de dos tablas distintas.

ArrayList<Object> itemsToGet = new ArrayList<Object>();

ForumItem forumItem = new ForumItem();


forumItem.setForumName("Amazon DynamoDB");
itemsToGet.add(forumItem);

ThreadItem threadItem = new ThreadItem();


threadItem.setForumName("Amazon DynamoDB");
threadItem.setSubject("Amazon DynamoDB thread 1 message text");
itemsToGet.add(threadItem);

Map<String, List<Object>> items = mapper.batchLoad(itemsToGet);

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.

En el siguiente código Java se eliminan dos elementos (libros) de la tabla ProductCatalog.

Book book1 = mapper.load(Book.class, 901);


Book book2 = mapper.load(Book.class, 902);
mapper.batchDelete(Arrays.asList(book1, book2));

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.

// Create a Forum item to save


Forum forumItem = new Forum();
forumItem.name = "Test BatchWrite Forum";

// Create a Thread item to save


Thread threadItem = new Thread();
threadItem.forumName = "AmazonDynamoDB";
threadItem.subject = "My sample question";

Versión de API 2012-08-10


244
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

// Load a ProductCatalog item to delete


Book book3 = mapper.load(Book.class, 903);

List<Object> objectsToWrite = Arrays.asList(forumItem, threadItem);


List<Book> objectsToDelete = Arrays.asList(book3);

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

Este método no admite lo siguiente:

• DynamoDBMapperConfig.SaveBehavior.

El siguiente código Java escribe un nuevo elemento en cada una de las tablas Forum y Thread de un
modo transaccional.

Thread s3ForumThread = new Thread();


s3ForumThread.forumName = "S3 Forum";
s3ForumThread.subject = "Sample Subject 1";
s3ForumThread.message = "Sample Question 1";

Forum s3Forum = new Forum();


s3Forum.name = "S3 Forum";
s3Forum.category = "Amazon Web Services";
s3Forum.threads = 1;

TransactionWriteRequest transactionWriteRequest = new TransactionWriteRequest();


transactionWriteRequest.addPut(s3Forum);
transactionWriteRequest.addPut(s3ForumThread);
mapper.transactionWrite(transactionWriteRequest);

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.

Forum dynamodbForum = new Forum();


dynamodbForum.name = "DynamoDB Forum";
Thread dynamodbForumThread = new Thread();
dynamodbForumThread.forumName = "DynamoDB Forum";

Versión de API 2012-08-10


245
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

TransactionLoadRequest transactionLoadRequest = new TransactionLoadRequest();


transactionLoadRequest.addLoad(dynamodbForum);
transactionLoadRequest.addLoad(dynamodbForumThread);
mapper.transactionLoad(transactionLoadRequest);

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 {

...

public S3Link productImage;

....

@DynamoDBAttribute(attributeName = "ProductImage")
public S3Link getProductImage() {
return productImage;
}

public void setProductImage(S3Link productImage) {


this.productImage = 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.

CatalogItem item = new CatalogItem();

item.id = 150;
item.title = "Book 150 Title";

String myS3Bucket = "myS3bucket";


String myS3Key = "productImages/book_150_cover.jpg";
item.setProductImage(mapper.createS3Link(myS3Bucket, myS3Key));

item.getProductImage().uploadFrom(new File("/file/path/book_150_cover.jpg"));

Versión de API 2012-08-10


246
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

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.

Ajustes de configuración opcionales para DynamoDBMapper


Al crear una instancia de DynamoDBMapper, presenta algunos comportamientos predeterminados que se
pueden anular mediante la clase DynamoDBMapperConfig.

En el siguiente fragmento de código se crea una clase DynamoDBMapper con ajustes personalizados:

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();

DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder()


.withSaveBehavior(DynamoDBMapperConfig.SaveBehavior.CLOBBER)
.withConsistentReads(DynamoDBMapperConfig.ConsistentReads.CONSISTENT)
.withTableNameOverride(null)

.withPaginationLoadingStrategy(DynamoDBMapperConfig.PaginationLoadingStrategy.EAGER_LOADING)
.build();

DynamoDBMapper mapper = new DynamoDBMapper(client, mapperConfig);

Para obtener más información, consulteDynamoDBMapperConfigen laAWS SDK for JavaReferencia de la


API.

Puede usar los argumentos siguientes para una instancia de DynamoDBMapperConfig:

• Un valor de enumeración DynamoDBMapperConfig.ConsistentReads:


• EVENTUAL: la instancia de mapeador utiliza una solicitud de lectura consistente final.
• CONSISTENT: la instancia de mapeador utiliza una solicitud de lectura de consistencia alta. Puede
usar este ajuste opcional con las operaciones load, query o scan operations. Las lecturas
de consistencia alta afectan al desempeño y a la facturación; consulte elPágina de detalles del
productoPara obtener más información.

Si no especifica un ajuste de consistencia de lectura para la instancia de mapeador, el valor


predeterminado es EVENTUAL.
• Un valor de enumeración DynamoDBMapperConfig.PaginationLoadingStrategy: controla cómo
la instancia de mapeador procesa una lista de datos paginados, como los resultados de una operación
query o scan:
• LAZY_LOADING: la instancia de mapeador carga los datos cuando es posible y conserva todos los
resultados cargados en la memoria.
• EAGER_LOADING: la instancia de mapeador carga los datos tan pronto como se inicializa la lista.
• ITERATION_ONLY: solo se puede usar un iterador para leer datos en la lista. Durante la iteración,
la lista borrará todos los resultados anteriores antes de cargar la página siguiente, para que la lista
conserve como máximo una página de resultados cargados en la memoria. Por consiguiente, la lista
solamente se puede recorrer en iteración una vez. Esta estrategia se recomienda para administrar
elementos de gran tamaño, con el fin de reducir la sobrecarga de la memoria.

Versión de API 2012-08-10


247
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

Si no especifica una estrategia de carga de paginación para la instancia de mapeador, el valor


predeterminado es LAZY_LOADING.
• Un valor de enumeración DynamoDBMapperConfig.SaveBehavior: especifica cómo la instancia de
mapeador administrará los atributos durante las operaciones de almacenamiento:
• UPDATE: durante una operación de almacenamiento, se actualizan todos los atributos modelados
y los atributos no modelados no sufren cambios. Los tipos numéricos primitivos (byte, int, long) se
establecen en 0. Los tipos de objeto se establecen en null.
• CLOBBER: borra y sustituye los atributos, incluidos los no modelados, durante una operación de
almacenamiento. Para ello, se elimina el elemento y se vuelve a crear. También se descartan las
restricciones de los campos con versiones.

Si no especifica el comportamiento al guardar para la instancia de mapeador, el valor predeterminado es


UPDATE.
Note

Las operaciones transaccionales de DynamoDBMapper no admiten la enumeración


DynamoDBMapperConfig.SaveBehavior.
• ADynamoDBMapperConfig.TableNameOverrideObject: indica a la instancia de mapeador que pase
por alto el nombre de tabla especificado por elDynamoDBTableEn su lugar, use el nombre de tabla
alternativo suministrado. Esto resulta útil cuando se particionan los datos en varias tablas en tiempo de
ejecución.

Puede anular el objeto de configuración predeterminado para DynamoDBMapper en cada operación,


conforme lo necesite.

Ejemplo: Operaciones de CRUD


En el siguiente ejemplo de código Java se declara una clase CatalogItem que tiene las propiedades
Id, Title, ISBN y Authors. Se utilizan las anotaciones para mapear estas propiedades
alProductCatalogen DynamoDB. En el ejemplo se utiliza DynamoDBMapper para guardar un objeto de
libro, recuperarlo, actualizarlo y eliminarlo.
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.datamodeling;

Versión de API 2012-08-10


248
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

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;

public class DynamoDBMapperCRUDExample {

static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();

public static void main(String[] args) throws IOException {


testCRUDOperations();
System.out.println("Example complete!");
}

@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;
}

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;
}

Versión de API 2012-08-10


249
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

@Override
public String toString() {
return "Book [ISBN=" + ISBN + ", bookAuthors=" + bookAuthors + ", id=" + id +
", title=" + title + "]";
}
}

private static void testCRUDOperations() {

CatalogItem item = new CatalogItem();


item.setId(601);
item.setTitle("Book 601");
item.setISBN("611-1111111111");
item.setBookAuthors(new HashSet<String>(Arrays.asList("Author1", "Author2")));

// Save the item (book).


DynamoDBMapper mapper = new DynamoDBMapper(client);
mapper.save(item);

// Retrieve the item.


CatalogItem itemRetrieved = mapper.load(CatalogItem.class, 601);
System.out.println("Item retrieved:");
System.out.println(itemRetrieved);

// Update the item.


itemRetrieved.setISBN("622-2222222222");
itemRetrieved.setBookAuthors(new HashSet<String>(Arrays.asList("Author1",
"Author3")));
mapper.save(itemRetrieved);
System.out.println("Item updated:");
System.out.println(itemRetrieved);

// Retrieve the updated item.


DynamoDBMapperConfig config = DynamoDBMapperConfig.builder()
.withConsistentReads(DynamoDBMapperConfig.ConsistentReads.CONSISTENT)
.build();
CatalogItem updatedItem = mapper.load(CatalogItem.class, 601, config);
System.out.println("Retrieved the previously updated item:");
System.out.println(updatedItem);

// Delete the item.


mapper.delete(updatedItem);

// Try to retrieve deleted item.


CatalogItem deletedItem = mapper.load(CatalogItem.class, updatedItem.getId(),
config);
if (deletedItem == null) {
System.out.println("Done - Sample item is deleted.");
}
}
}

Ejemplo: Operaciones de escritura por lotes


En el siguiente ejemplo de código Java se declaraBook,Forum,Thread, yReplyy las asigna a las tablas
de Amazon DynamoDB mediante la herramientaDynamoDBMapperClase de.

En el código se ilustran las siguientes operaciones de escritura por lotes:

• batchSavepara colocar elementos de libro en elProductCatalogTabla de.


• batchDeletepara eliminar elementos del cuadro de diálogoProductCatalogTabla de.
• batchWritepara colocar y eliminar elementos delForumy laThreadTabla de.

Versión de API 2012-08-10


250
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

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;

public class DynamoDBMapperBatchWriteExample {

static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


static SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-
dd'T'HH:mm:ss.SSS'Z'");

public static void main(String[] args) throws Exception {


try {

DynamoDBMapper mapper = new DynamoDBMapper(client);

testBatchSave(mapper);
testBatchDelete(mapper);
testBatchWrite(mapper);

System.out.println("Example complete!");

}
catch (Throwable t) {
System.err.println("Error running the DynamoDBMapperBatchWriteExample: " + t);
t.printStackTrace();
}
}

private static void testBatchSave(DynamoDBMapper mapper) {

Versión de API 2012-08-10


251
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

Book book1 = new Book();


book1.id = 901;
book1.inPublication = true;
book1.ISBN = "902-11-11-1111";
book1.pageCount = 100;
book1.price = 10;
book1.productCategory = "Book";
book1.title = "My book created in batch write";

Book book2 = new Book();


book2.id = 902;
book2.inPublication = true;
book2.ISBN = "902-11-12-1111";
book2.pageCount = 200;
book2.price = 20;
book2.productCategory = "Book";
book2.title = "My second book created in batch write";

Book book3 = new Book();


book3.id = 903;
book3.inPublication = false;
book3.ISBN = "902-11-13-1111";
book3.pageCount = 300;
book3.price = 25;
book3.productCategory = "Book";
book3.title = "My third book created in batch write";

System.out.println("Adding three books to ProductCatalog table.");


mapper.batchSave(Arrays.asList(book1, book2, book3));
}

private static void testBatchDelete(DynamoDBMapper mapper) {

Book book1 = mapper.load(Book.class, 901);


Book book2 = mapper.load(Book.class, 902);
System.out.println("Deleting two books from the ProductCatalog table.");
mapper.batchDelete(Arrays.asList(book1, book2));
}

private static void testBatchWrite(DynamoDBMapper mapper) {

// Create Forum item to save


Forum forumItem = new Forum();
forumItem.name = "Test BatchWrite Forum";
forumItem.threads = 0;
forumItem.category = "Amazon Web Services";

// Create Thread item to save


Thread threadItem = new Thread();
threadItem.forumName = "AmazonDynamoDB";
threadItem.subject = "My sample question";
threadItem.message = "BatchWrite message";
List<String> tags = new ArrayList<String>();
tags.add("batch operations");
tags.add("write");
threadItem.tags = new HashSet<String>(tags);

// Load ProductCatalog item to delete


Book book3 = mapper.load(Book.class, 903);

List<Object> objectsToWrite = Arrays.asList(forumItem, threadItem);


List<Book> objectsToDelete = Arrays.asList(book3);

DynamoDBMapperConfig config = DynamoDBMapperConfig.builder()


.withSaveBehavior(DynamoDBMapperConfig.SaveBehavior.CLOBBER)

Versión de API 2012-08-10


252
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

.build();

mapper.batchWrite(objectsToWrite, objectsToDelete, config);


}

@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;
}

public void setId(int 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 = "Price")
public int getPrice() {
return price;
}

public void setPrice(int price) {


this.price = price;
}

@DynamoDBAttribute(attributeName = "PageCount")
public int getPageCount() {
return pageCount;
}

public void setPageCount(int pageCount) {


this.pageCount = pageCount;
}

@DynamoDBAttribute(attributeName = "ProductCategory")
public String getProductCategory() {
return productCategory;
}

Versión de API 2012-08-10


253
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

public void setProductCategory(String productCategory) {


this.productCategory = productCategory;
}

@DynamoDBAttribute(attributeName = "InPublication")
public boolean getInPublication() {
return inPublication;
}

public void setInPublication(boolean inPublication) {


this.inPublication = 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;
}

public void setId(String id) {


this.id = id;
}

// Sort key
@DynamoDBRangeKey(attributeName = "ReplyDateTime")
public String getReplyDateTime() {
return replyDateTime;
}

public void setReplyDateTime(String replyDateTime) {


this.replyDateTime = replyDateTime;
}

@DynamoDBAttribute(attributeName = "Message")
public String getMessage() {
return message;
}

public void setMessage(String message) {


this.message = message;
}

@DynamoDBAttribute(attributeName = "PostedBy")
public String getPostedBy() {
return postedBy;
}

public void setPostedBy(String postedBy) {


this.postedBy = postedBy;
}

Versión de API 2012-08-10


254
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

@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;
}

public void setForumName(String forumName) {


this.forumName = forumName;
}

// Sort key
@DynamoDBRangeKey(attributeName = "Subject")
public String getSubject() {
return subject;
}

public void setSubject(String subject) {


this.subject = subject;
}

@DynamoDBAttribute(attributeName = "Message")
public String getMessage() {
return message;
}

public void setMessage(String message) {


this.message = message;
}

@DynamoDBAttribute(attributeName = "LastPostedDateTime")
public String getLastPostedDateTime() {
return lastPostedDateTime;
}

public void setLastPostedDateTime(String lastPostedDateTime) {


this.lastPostedDateTime = lastPostedDateTime;
}

@DynamoDBAttribute(attributeName = "LastPostedBy")
public String getLastPostedBy() {
return lastPostedBy;
}

public void setLastPostedBy(String lastPostedBy) {


this.lastPostedBy = lastPostedBy;
}

@DynamoDBAttribute(attributeName = "Tags")
public Set<String> getTags() {
return tags;
}

Versión de API 2012-08-10


255
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

public void setTags(Set<String> tags) {


this.tags = tags;
}

@DynamoDBAttribute(attributeName = "Answered")
public int getAnswered() {
return answered;
}

public void setAnswered(int answered) {


this.answered = answered;
}

@DynamoDBAttribute(attributeName = "Views")
public int getViews() {
return views;
}

public void setViews(int views) {


this.views = views;
}

@DynamoDBAttribute(attributeName = "Replies")
public int getReplies() {
return replies;
}

public void setReplies(int replies) {


this.replies = 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;
}

public void setName(String name) {


this.name = name;
}

@DynamoDBAttribute(attributeName = "Category")
public String getCategory() {
return category;
}

public void setCategory(String category) {


this.category = category;
}

@DynamoDBAttribute(attributeName = "Threads")
public int getThreads() {
return threads;
}

public void setThreads(int threads) {


this.threads = threads;
}

Versión de API 2012-08-10


256
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

}
}

Ejemplo: Consulta y examen

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 clase Book se mapea a la tabla ProductCatalog


• Las clases Forum, Thread y Reply se mapean a las tablas del mismo nombre.

A continuación, en el ejemplo se usa para ejecutar las siguientes operaciones de consulta y


examen.DynamoDBMapperinstancia.

• Obtenga un libro por Id.

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.

La clave principal de la tabla Reply consta de los atributos Id y ReplyDateTime. ReplyDateTime es


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.
• Examinar la tabla ProductCatalog para buscar los libros cuyo precio sea menor que un valor
especificado.

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

Versión de API 2012-08-10


257
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

* 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;

public class DynamoDBMapperQueryScanExample {

static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();

public static void main(String[] args) throws Exception {


try {

DynamoDBMapper mapper = new DynamoDBMapper(client);

// Get a book - Id=101


GetBook(mapper, 101);
// Sample forum and thread to test queries.
String forumName = "Amazon DynamoDB";
String threadSubject = "DynamoDB Thread 1";
// Sample queries.
FindRepliesInLast15Days(mapper, forumName, threadSubject);
FindRepliesPostedWithinTimePeriod(mapper, forumName, threadSubject);

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

Versión de API 2012-08-10


258
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

}
}

private static void GetBook(DynamoDBMapper mapper, int id) throws Exception {


System.out.println("GetBook: Get book Id='101' ");
System.out.println("Book table has no sort key. You can do GetItem, but not
Query.");
Book book = mapper.load(Book.class, id);
System.out.format("Id = %s Title = %s, ISBN = %s %n", book.getId(),
book.getTitle(), book.getISBN());
}

private static void FindRepliesInLast15Days(DynamoDBMapper mapper, String forumName,


String threadSubject)
throws Exception {
System.out.println("FindRepliesInLast15Days: Replies within last 15 days.");

String partitionKey = forumName + "#" + threadSubject;

long twoWeeksAgoMilli = (new Date()).getTime() - (15L * 24L * 60L * 60L * 1000L);


Date twoWeeksAgo = new Date();
twoWeeksAgo.setTime(twoWeeksAgoMilli);
SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-
dd'T'HH:mm:ss.SSS'Z'");
dateFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
String twoWeeksAgoStr = dateFormatter.format(twoWeeksAgo);

Map<String, AttributeValue> eav = new HashMap<String, AttributeValue>();


eav.put(":val1", new AttributeValue().withS(partitionKey));
eav.put(":val2", new AttributeValue().withS(twoWeeksAgoStr.toString()));

DynamoDBQueryExpression<Reply> queryExpression = new


DynamoDBQueryExpression<Reply>()
.withKeyConditionExpression("Id = :val1 and ReplyDateTime
> :val2").withExpressionAttributeValues(eav);

List<Reply> latestReplies = mapper.query(Reply.class, queryExpression);

for (Reply reply : latestReplies) {


System.out.format("Id=%s, Message=%s, PostedBy=%s %n, ReplyDateTime=%s %n",
reply.getId(),
reply.getMessage(), reply.getPostedBy(), reply.getReplyDateTime());
}
}

private static void FindRepliesPostedWithinTimePeriod(DynamoDBMapper mapper, String


forumName, String threadSubject)
throws Exception {
String partitionKey = forumName + "#" + threadSubject;

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

Versión de API 2012-08-10


259
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

dateFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
String startDate = dateFormatter.format(startDateMilli);
String endDate = dateFormatter.format(endDateMilli);

Map<String, AttributeValue> eav = new HashMap<String, AttributeValue>();


eav.put(":val1", new AttributeValue().withS(partitionKey));
eav.put(":val2", new AttributeValue().withS(startDate));
eav.put(":val3", new AttributeValue().withS(endDate));

DynamoDBQueryExpression<Reply> queryExpression = new


DynamoDBQueryExpression<Reply>()
.withKeyConditionExpression("Id = :val1 and ReplyDateTime between :val2
and :val3")
.withExpressionAttributeValues(eav);

List<Reply> betweenReplies = mapper.query(Reply.class, queryExpression);

for (Reply reply : betweenReplies) {


System.out.format("Id=%s, Message=%s, PostedBy=%s %n, PostedDateTime=%s %n",
reply.getId(),
reply.getMessage(), reply.getPostedBy(), reply.getReplyDateTime());
}

private static void FindBooksPricedLessThanSpecifiedValue(DynamoDBMapper mapper, String


value) throws Exception {

System.out.println("FindBooksPricedLessThanSpecifiedValue: Scan ProductCatalog.");

Map<String, AttributeValue> eav = new HashMap<String, AttributeValue>();


eav.put(":val1", new AttributeValue().withN(value));
eav.put(":val2", new AttributeValue().withS("Book"));

DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()


.withFilterExpression("Price < :val1 and ProductCategory
= :val2").withExpressionAttributeValues(eav);

List<Book> scanResult = mapper.scan(Book.class, scanExpression);

for (Book book : scanResult) {


System.out.println(book);
}
}

private static void FindBicyclesOfSpecificTypeWithMultipleThreads(DynamoDBMapper


mapper, int numberOfThreads,
String bicycleType) throws Exception {

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

DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()


.withFilterExpression("ProductCategory = :val1 and BicycleType
= :val2").withExpressionAttributeValues(eav);

List<Bicycle> scanResult = mapper.parallelScan(Bicycle.class, scanExpression,


numberOfThreads);
for (Bicycle bicycle : scanResult) {
System.out.println(bicycle);
}
}

Versión de API 2012-08-10


260
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

@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;
}

public void setId(int 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 = "Price")
public int getPrice() {
return price;
}

public void setPrice(int price) {


this.price = price;
}

@DynamoDBAttribute(attributeName = "PageCount")
public int getPageCount() {
return pageCount;
}

public void setPageCount(int pageCount) {


this.pageCount = pageCount;
}

@DynamoDBAttribute(attributeName = "ProductCategory")
public String getProductCategory() {
return productCategory;
}

public void setProductCategory(String productCategory) {


this.productCategory = productCategory;
}

@DynamoDBAttribute(attributeName = "InPublication")
public boolean getInPublication() {

Versión de API 2012-08-10


261
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

return inPublication;
}

public void setInPublication(boolean inPublication) {


this.inPublication = 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;
}

public void setId(int id) {


this.id = id;
}

@DynamoDBAttribute(attributeName = "Title")
public String getTitle() {
return title;
}

public void setTitle(String title) {


this.title = title;
}

@DynamoDBAttribute(attributeName = "Description")
public String getDescription() {
return description;
}

public void setDescription(String description) {


this.description = description;
}

@DynamoDBAttribute(attributeName = "BicycleType")
public String getBicycleType() {
return bicycleType;
}

public void setBicycleType(String bicycleType) {


this.bicycleType = bicycleType;
}

@DynamoDBAttribute(attributeName = "Brand")
public String getBrand() {
return brand;

Versión de API 2012-08-10


262
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

public void setBrand(String brand) {


this.brand = brand;
}

@DynamoDBAttribute(attributeName = "Price")
public int getPrice() {
return price;
}

public void setPrice(int price) {


this.price = price;
}

@DynamoDBAttribute(attributeName = "Color")
public List<String> getColor() {
return color;
}

public void setColor(List<String> color) {


this.color = color;
}

@DynamoDBAttribute(attributeName = "ProductCategory")
public String getProductCategory() {
return productCategory;
}

public void setProductCategory(String productCategory) {


this.productCategory = 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;
}

public void setId(String id) {


this.id = id;
}

// Range key
@DynamoDBRangeKey(attributeName = "ReplyDateTime")
public String getReplyDateTime() {
return replyDateTime;
}

public void setReplyDateTime(String replyDateTime) {

Versión de API 2012-08-10


263
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

this.replyDateTime = replyDateTime;
}

@DynamoDBAttribute(attributeName = "Message")
public String getMessage() {
return message;
}

public void setMessage(String message) {


this.message = message;
}

@DynamoDBAttribute(attributeName = "PostedBy")
public String getPostedBy() {
return postedBy;
}

public void setPostedBy(String postedBy) {


this.postedBy = 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;
}

public void setForumName(String forumName) {


this.forumName = forumName;
}

// Range key
@DynamoDBRangeKey(attributeName = "Subject")
public String getSubject() {
return subject;
}

public void setSubject(String subject) {


this.subject = subject;
}

@DynamoDBAttribute(attributeName = "Message")
public String getMessage() {
return message;
}

public void setMessage(String message) {


this.message = message;
}

@DynamoDBAttribute(attributeName = "LastPostedDateTime")
public String getLastPostedDateTime() {
return lastPostedDateTime;

Versión de API 2012-08-10


264
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

public void setLastPostedDateTime(String lastPostedDateTime) {


this.lastPostedDateTime = lastPostedDateTime;
}

@DynamoDBAttribute(attributeName = "LastPostedBy")
public String getLastPostedBy() {
return lastPostedBy;
}

public void setLastPostedBy(String lastPostedBy) {


this.lastPostedBy = lastPostedBy;
}

@DynamoDBAttribute(attributeName = "Tags")
public Set<String> getTags() {
return tags;
}

public void setTags(Set<String> tags) {


this.tags = tags;
}

@DynamoDBAttribute(attributeName = "Answered")
public int getAnswered() {
return answered;
}

public void setAnswered(int answered) {


this.answered = answered;
}

@DynamoDBAttribute(attributeName = "Views")
public int getViews() {
return views;
}

public void setViews(int views) {


this.views = views;
}

@DynamoDBAttribute(attributeName = "Replies")
public int getReplies() {
return replies;
}

public void setReplies(int replies) {


this.replies = 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;
}

public void setName(String name) {


this.name = name;

Versión de API 2012-08-10


265
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

@DynamoDBAttribute(attributeName = "Category")
public String getCategory() {
return category;
}

public void setCategory(String category) {


this.category = category;
}

@DynamoDBAttribute(attributeName = "Threads")
public int getThreads() {
return threads;
}

public void setThreads(int threads) {


this.threads = threads;
}
}
}

Ejemplo: Operaciones de Transacción


En el siguiente ejemplo de código Java se declara unForumy aThready los asigna a las tablas de
DynamoDB mediante el métodoDynamoDBMapperClase de.

El código ilustra las siguientes operaciones transaccionales:

• 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;

Versión de API 2012-08-10


266
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

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;

public class DynamoDBMapperTransactionExample {

static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


static DynamoDBMapper mapper;

public static void main(String[] args) throws Exception {


try {

mapper = new DynamoDBMapper(client);

testPutAndUpdateInTransactionWrite();
testPutWithConditionalUpdateInTransactionWrite();
testPutWithConditionCheckInTransactionWrite();
testMixedOperationsInTransactionWrite();
testTransactionLoadWithSave();
testTransactionLoadWithTransactionWrite();
System.out.println("Example complete");

}
catch (Throwable t) {
System.err.println("Error running the DynamoDBMapperTransactionWriteExample: "
+ t);
t.printStackTrace();
}
}

private static void testTransactionLoadWithSave() {


// Create new Forum item for DynamoDB using save
Forum dynamodbForum = new Forum();
dynamodbForum.name = "DynamoDB Forum";
dynamodbForum.category = "Amazon Web Services";
dynamodbForum.threads = 0;
mapper.save(dynamodbForum);

// Add a thread to DynamoDB Forum


Thread dynamodbForumThread = new Thread();
dynamodbForumThread.forumName = "DynamoDB Forum";
dynamodbForumThread.subject = "Sample Subject 1";
dynamodbForumThread.message = "Sample Question 1";
mapper.save(dynamodbForumThread);

// Update DynamoDB Forum to reflect updated thread count


dynamodbForum.threads = 1;
mapper.save(dynamodbForum);

// Read DynamoDB Forum item and Thread item at the same time in a serializable
manner
TransactionLoadRequest transactionLoadRequest = new TransactionLoadRequest();

// Read entire item for DynamoDB Forum


transactionLoadRequest.addLoad(dynamodbForum);

Versión de API 2012-08-10


267
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

// Only read subject and message attributes from Thread item


DynamoDBTransactionLoadExpression loadExpressionForThread = new
DynamoDBTransactionLoadExpression()

.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);
}

private static void testTransactionLoadWithTransactionWrite() {


// Create new Forum item for DynamoDB using save
Forum dynamodbForum = new Forum();
dynamodbForum.name = "DynamoDB New Forum";
dynamodbForum.category = "Amazon Web Services";
dynamodbForum.threads = 0;
mapper.save(dynamodbForum);

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

// Read entire item for DynamoDB Forum


transactionLoadRequest.addLoad(dynamodbForum);

// Only read subject and message attributes from Thread item


DynamoDBTransactionLoadExpression loadExpressionForThread = new
DynamoDBTransactionLoadExpression()

.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);
}

Versión de API 2012-08-10


268
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

private static void testPutAndUpdateInTransactionWrite() {


// Create new Forum item for S3 using save
Forum s3Forum = new Forum();
s3Forum.name = "S3 Forum";
s3Forum.category = "Core Amazon Web Services";
s3Forum.threads = 0;
mapper.save(s3Forum);

// 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);
}

private static void testPutWithConditionalUpdateInTransactionWrite() {


// Create new Thread item for DynamoDB forum and update thread count in DynamoDB
forum
// if the DynamoDB Forum exists
Thread dynamodbForumThread = new Thread();
dynamodbForumThread.forumName = "DynamoDB Forum";
dynamodbForumThread.subject = "Sample Subject 1";
dynamodbForumThread.message = "Sample Question 1";

Forum dynamodbForum = new Forum();


dynamodbForum.name = "DynamoDB Forum";
dynamodbForum.category = "Amazon Web Services";
dynamodbForum.threads = 1;

DynamoDBTransactionWriteExpression transactionWriteExpression = new


DynamoDBTransactionWriteExpression()

.withConditionExpression("attribute_exists(Category)");

TransactionWriteRequest transactionWriteRequest = new TransactionWriteRequest();


transactionWriteRequest.addPut(dynamodbForumThread);
transactionWriteRequest.addUpdate(dynamodbForum, transactionWriteExpression);
executeTransactionWrite(transactionWriteRequest);
}

private static void testPutWithConditionCheckInTransactionWrite() {


// Create new Thread item for DynamoDB forum and update thread count in DynamoDB
forum if a thread already exists
Thread dynamodbForumThread2 = new Thread();
dynamodbForumThread2.forumName = "DynamoDB Forum";
dynamodbForumThread2.subject = "Sample Subject 2";
dynamodbForumThread2.message = "Sample Question 2";

Thread dynamodbForumThread1 = new Thread();


dynamodbForumThread1.forumName = "DynamoDB Forum";
dynamodbForumThread1.subject = "Sample Subject 1";
DynamoDBTransactionWriteExpression conditionExpressionForConditionCheck = new
DynamoDBTransactionWriteExpression()

.withConditionExpression("attribute_exists(Subject)");

Forum dynamodbForum = new Forum();


dynamodbForum.name = "DynamoDB Forum";
dynamodbForum.category = "Amazon Web Services";
dynamodbForum.threads = 2;

Versión de API 2012-08-10


269
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

TransactionWriteRequest transactionWriteRequest = new TransactionWriteRequest();


transactionWriteRequest.addPut(dynamodbForumThread2);
transactionWriteRequest.addConditionCheck(dynamodbForumThread1,
conditionExpressionForConditionCheck);
transactionWriteRequest.addUpdate(dynamodbForum);
executeTransactionWrite(transactionWriteRequest);
}

private static void testMixedOperationsInTransactionWrite() {


// Create new Thread item for S3 forum and delete "Sample Subject 1" Thread from
DynamoDB forum if
// "Sample Subject 2" Thread exists in DynamoDB forum
Thread s3ForumThread = new Thread();
s3ForumThread.forumName = "S3 Forum";
s3ForumThread.subject = "Sample Subject 1";
s3ForumThread.message = "Sample Question 1";

Forum s3Forum = new Forum();


s3Forum.name = "S3 Forum";
s3Forum.category = "Amazon Web Services";
s3Forum.threads = 1;

Thread dynamodbForumThread1 = new Thread();


dynamodbForumThread1.forumName = "DynamoDB Forum";
dynamodbForumThread1.subject = "Sample Subject 1";

Thread dynamodbForumThread2 = new Thread();


dynamodbForumThread2.forumName = "DynamoDB Forum";
dynamodbForumThread2.subject = "Sample Subject 2";
DynamoDBTransactionWriteExpression conditionExpressionForConditionCheck = new
DynamoDBTransactionWriteExpression()

.withConditionExpression("attribute_exists(Subject)");

Forum dynamodbForum = new Forum();


dynamodbForum.name = "DynamoDB Forum";
dynamodbForum.category = "Amazon Web Services";
dynamodbForum.threads = 1;

TransactionWriteRequest transactionWriteRequest = new TransactionWriteRequest();


transactionWriteRequest.addPut(s3ForumThread);
transactionWriteRequest.addUpdate(s3Forum);
transactionWriteRequest.addDelete(dynamodbForumThread1);
transactionWriteRequest.addConditionCheck(dynamodbForumThread2,
conditionExpressionForConditionCheck);
transactionWriteRequest.addUpdate(dynamodbForum);
executeTransactionWrite(transactionWriteRequest);
}
private static List<Object> executeTransactionLoad(TransactionLoadRequest
transactionLoadRequest) {
List<Object> loadedObjects = new ArrayList<Object>();
try {
loadedObjects = mapper.transactionLoad(transactionLoadRequest);
} catch (DynamoDBMappingException ddbme) {
System.err.println("Client side error in Mapper, fix before retrying. Error: "
+ ddbme.getMessage());
} catch (ResourceNotFoundException rnfe) {
System.err.println("One of the tables was not found, verify table exists before
retrying. Error: " + rnfe.getMessage());
} catch (InternalServerErrorException ise) {
System.err.println("Internal Server Error, generally safe to retry with back-
off. Error: " + ise.getMessage());
} catch (TransactionCanceledException tce) {

Versión de API 2012-08-10


270
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

System.err.println("Transaction Canceled, implies a client issue, fix before


retrying. Error: " + tce.getMessage());
} catch (Exception ex) {
System.err.println("An exception occurred, investigate and configure retry
strategy. Error: " + ex.getMessage());
}
return loadedObjects;
}
private static void executeTransactionWrite(TransactionWriteRequest
transactionWriteRequest) {
try {
mapper.transactionWrite(transactionWriteRequest);
} catch (DynamoDBMappingException ddbme) {
System.err.println("Client side error in Mapper, fix before retrying. Error: "
+ ddbme.getMessage());
} catch (ResourceNotFoundException rnfe) {
System.err.println("One of the tables was not found, verify table exists before
retrying. Error: " + rnfe.getMessage());
} catch (InternalServerErrorException ise) {
System.err.println("Internal Server Error, generally safe to retry with back-
off. Error: " + ise.getMessage());
} catch (TransactionCanceledException tce) {
System.err.println("Transaction Canceled, implies a client issue, fix before
retrying. Error: " + tce.getMessage());
} catch (Exception ex) {
System.err.println("An exception occurred, investigate and configure retry
strategy. Error: " + ex.getMessage());
}
}

@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;
}

public void setForumName(String forumName) {


this.forumName = forumName;
}

// Sort key
@DynamoDBRangeKey(attributeName = "Subject")
public String getSubject() {
return subject;
}

public void setSubject(String subject) {


this.subject = subject;
}

@DynamoDBAttribute(attributeName = "Message")
public String getMessage() {
return message;
}

Versión de API 2012-08-10


271
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

public void setMessage(String message) {


this.message = message;
}

@DynamoDBAttribute(attributeName = "LastPostedDateTime")
public String getLastPostedDateTime() {
return lastPostedDateTime;
}

public void setLastPostedDateTime(String lastPostedDateTime) {


this.lastPostedDateTime = lastPostedDateTime;
}

@DynamoDBAttribute(attributeName = "LastPostedBy")
public String getLastPostedBy() {
return lastPostedBy;
}

public void setLastPostedBy(String lastPostedBy) {


this.lastPostedBy = lastPostedBy;
}

@DynamoDBAttribute(attributeName = "Tags")
public Set<String> getTags() {
return tags;
}

public void setTags(Set<String> tags) {


this.tags = tags;
}

@DynamoDBAttribute(attributeName = "Answered")
public int getAnswered() {
return answered;
}

public void setAnswered(int answered) {


this.answered = answered;
}

@DynamoDBAttribute(attributeName = "Views")
public int getViews() {
return views;
}

public void setViews(int views) {


this.views = views;
}

@DynamoDBAttribute(attributeName = "Replies")
public int getReplies() {
return replies;
}

public void setReplies(int replies) {


this.replies = replies;
}

@DynamoDBTable(tableName = "Forum")
public static class Forum {
private String name;
private String category;
private int threads;

Versión de API 2012-08-10


272
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

// Partition key
@DynamoDBHashKey(attributeName = "Name")
public String getName() {
return name;
}

public void setName(String name) {


this.name = name;
}

@DynamoDBAttribute(attributeName = "Category")
public String getCategory() {
return category;
}

public void setCategory(String category) {


this.category = category;
}

@DynamoDBAttribute(attributeName = "Threads")
public int getThreads() {
return threads;
}

public void setThreads(int threads) {


this.threads = threads;
}
}
}

Bloqueo optimista con el número de versión


Bloqueo optimistaEs una estrategia para asegurarse de que el elemento del lado del cliente que se va
a actualizar (o eliminar) sea el mismo que figura en Amazon DynamoDB. Si utiliza esta estrategia, las
escrituras en su base de datos se protegen contra posibles sobrescrituras de otros y viceversa.

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.

ConditionalCheckFailedException se lanza si:

• Utiliza el bloqueo optimista con @DynamoDBVersionAttribute y el valor de versión en el servidor es


distinto del valor en el lado del cliente.
• Especifique sus propias limitaciones condicionales al guardar los datos utilizando DynamoDBMapper con
DynamoDBSaveExpression y estas limitaciones han fallado.

Versión de API 2012-08-10


273
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

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 {

private Integer id;


private String title;
private String ISBN;
private Set<String> bookAuthors;
private String someProp;
private Long version;

@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:

• save— Para un nuevo elemento, elDynamoDBMapperAsigna un número de versión inicial 1. Si recupera


un elemento, actualiza una o varias de sus propiedades e intenta guardar los cambios, la operación
de almacenamiento solamente se lleva a cabo si el número de versión del lado del cliente coincide
con el número de versión del lado del servidor. DynamoDBMapper incrementa el número de versión
automáticamente.

Versión de API 2012-08-10


274
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

• delete— Eldeletetoma un objeto como parámetro, y el métodoDynamoDBMapperlleva a cabo


una comprobación de versión antes de eliminar el elemento. La comprobación de versión se puede
deshabilitar si se especifica DynamoDBMapperConfig.SaveBehavior.CLOBBER en la solicitud.

La implementación interna del bloqueo optimista dentro deDynamoDBMapperSe utiliza la compatibilidad


con las acciones de actualización condicional y eliminación condicional que DynamoDB proporciona.
• transactionWrite —
• Put— Para un nuevo elemento, elDynamoDBMapperAsigna un número de versión inicial 1. Si
recupera un elemento, actualiza una o varias de sus propiedades e intenta guardar los cambios, la
operación put solamente se lleva a cabo si el número de versión del lado del cliente coincide con
el número de versión del lado del servidor. DynamoDBMapper incrementa el número de versión
automáticamente.
• Update— Para un nuevo elemento, elDynamoDBMapperAsigna un número de versión inicial 1. Si
recupera un elemento, actualiza una o varias de sus propiedades e intenta guardar los cambios, la
operación update solamente se lleva a cabo si el número de versión del lado del cliente coincide
con el número de versión del lado del servidor. DynamoDBMapper incrementa el número de versión
automáticamente.
• Delete— ElDynamoDBMapperlleva a cabo una comprobación de versión antes de eliminar el
elemento. La operación de eliminación solo se realiza correctamente si coincide el número de versión
en el lado del cliente y en el lado del servidor.
• ConditionCheck— El@DynamoDBVersionAttributela anotación no es compatible
conConditionCheck. Se producirá una excepción SdkClientException cuando un elemento
ConditionCheck se anote con @DynamoDBVersionAttribute.

Deshabilitación del bloqueo optimista


Para deshabilitar el bloqueo optimista, puede cambiar el valor de enumeración
DynamoDBMapperConfig.SaveBehavior de UPDATE a CLOBBER. Para ello, puede crear una instancia
de DynamoDBMapperConfig que omita la comprobación de versión y usar esta instancia en todas
las solicitudes. Para obtener información acerca de DynamoDBMapperConfig.SaveBehavior y
otros parámetros opcionales de DynamoDBMapper, consulte Ajustes de configuración opcionales para
DynamoDBMapper (p. 247).

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

El método transactionWrite method no admite la configuración


DynamoDBMapperConfig.SaveBehavior. No se admite la deshabilitación del bloqueo optimista
para transactionWrite.

Example

DynamoDBMapper mapper = new DynamoDBMapper(client);

// Load a catalog item.


CatalogItem item = mapper.load(CatalogItem.class, 101);
item.setTitle("This is a new title for the item");
...
// Save the item.
mapper.save(item,
new DynamoDBMapperConfig(
DynamoDBMapperConfig.SaveBehavior.CLOBBER));

Versión de API 2012-08-10


275
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

Mapeo de datos arbitrarios


Además de los tipos Java compatibles (consulteTipos de datos admitidos (p. 233)), puede utilizar
tipos de la aplicación para los cuales no exista un mapeo directo a los tipos de Amazon DynamoDB.
Para asignar estos tipos, debe proporcionar una implementación que convierta el tipo complejo en un
tipo admitido por DynamoDB y viceversa, y anotar el método de acceso al tipo complejo mediante el
método@DynamoDBTypeConvertedanotación. El código convertidor transforma los datos al guardar o
cargar los objetos. También se usa para todas las operaciones que consumen tipos complejos. Tenga
en cuenta que, al comparar datos durante las operaciones de consulta y examen, las comparaciones se
realizan respecto a los datos almacenados en DynamoDB.

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;

public class DynamoDBMapperExample {

static AmazonDynamoDB client;

Versión de API 2012-08-10


276
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

public static void main(String[] args) throws IOException {

// Set the AWS region you want to access.


Regions usWest2 = Regions.US_WEST_2;
client = AmazonDynamoDBClientBuilder.standard().withRegion(usWest2).build();

DimensionType dimType = new DimensionType();


dimType.setHeight("8.00");
dimType.setLength("11.0");
dimType.setThickness("1.0");

Book book = new Book();


book.setId(502);
book.setTitle("Book 502");
book.setISBN("555-5555555555");
book.setBookAuthors(new HashSet<String>(Arrays.asList("Author1", "Author2")));
book.setDimensions(dimType);

DynamoDBMapper mapper = new DynamoDBMapper(client);


mapper.save(book);

Book bookRetrieved = mapper.load(Book.class, 502);


System.out.println("Book info: " + "\n" + bookRetrieved);

bookRetrieved.getDimensions().setHeight("9.0");
bookRetrieved.getDimensions().setLength("12.0");
bookRetrieved.getDimensions().setThickness("2.0");

mapper.save(bookRetrieved);

bookRetrieved = mapper.load(Book.class, 502);


System.out.println("Updated book info: " + "\n" + 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;
}

public void setId(int 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;
}

Versión de API 2012-08-10


277
Amazon DynamoDB Guía para desarrolladores
Java: DynamoDBMapper

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;
}

@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 + "]";
}
}

static public class DimensionType {

private String length;


private String height;
private String thickness;

public String getLength() {


return length;
}

public void setLength(String length) {


this.length = length;
}

public String getHeight() {


return height;
}

public void setHeight(String height) {


this.height = height;
}

public String getThickness() {


return thickness;
}

public void setThickness(String thickness) {


this.thickness = thickness;
}
}

// Converts the complex type DimensionType to a string and vice-versa.

Versión de API 2012-08-10


278
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

static public class DimensionTypeConverter implements DynamoDBTypeConverter<String,


DimensionType> {

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

DimensionType itemDimension = new DimensionType();


try {
if (s != null && s.length() != 0) {
String[] data = s.split("x");
itemDimension.setLength(data[0].trim());
itemDimension.setHeight(data[1].trim());
itemDimension.setThickness(data[2].trim());
}
}
catch (Exception e) {
e.printStackTrace();
}

return itemDimension;
}
}
}

.NET: Modelo de documento


Temas
• Operaciones que no se admiten en el modelo de documento (p. 280)
• Tipos de datos admitidos (p. 280)
• Uso de elementos en DynamoDB con laAWS SDK for .NETModelo de documento (p. 281)
• Obtención de un elemento: Table.GetItem (p. 284)
• Eliminación de un elemento: Table.DeleteItem (p. 285)
• Actualización de un elemento: Table.UpdateItem (p. 286)
• Escritura por lotes: colocación y eliminación de varios elementos (p. 288)
• Ejemplo: Operaciones CRUD mediante elAWS SDK for .NETModelo de documento (p. 290)
• Ejemplo: Operaciones Batch utilizandoAWS SDK for .NETAPI de modelo de documento (p. 293)
• Consultar tablas en DynamoDB mediante el comandoAWS SDK for .NETModelo de
documento (p. 295)

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

Versión de API 2012-08-10


279
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

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.

Operaciones que no se admiten en el modelo de documento


Las clases del modelo de documento no se pueden usar para crear, actualizar ni eliminar tablas. Sin
embargo, el modelo de documento admite la mayoría de las operaciones de datos habituales.

Tipos de datos admitidos


El modelo de documento admite un conjunto de tipos de datos de .NET primitivos y tipos de datos de
colecciones. El modelo admite los siguientes tipos de datos primitivos.

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

Tipo de .NET primitivo Tipo DynamoDB

Todos los tipos de números N (tipo Number)

Todos los tipos de cadenas S (tipo String)

MemoryStream, byte[] B (tipo Binary)

bool N0 representa false y 1 representa true.

DateTime S (tipo String). LaDateTimeLos valores se


almacenan como cadenas con formato ISO-8601.

Guid S (tipo String).

Versión de API 2012-08-10


280
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

Tipo de .NET primitivo Tipo 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:

• Utilice DynamoDBBool para tipo booleano.


• Utilice DynamoDBNull para tipo nulo.
• Utilice DynamoDBList para tipo lista.
• Utilice Document para tipo mapa.

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

Uso de elementos en DynamoDB con laAWS SDK


for .NETModelo de documento
Temas
• Colocación de un elemento: método Table.PutItem (p. 282)
• Especificación de parámetros opcionales (p. 284)

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

Table table = Table.LoadTable(client, "ProductCatalog");

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.

Versión de API 2012-08-10


281
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

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

// Configuration object that specifies optional parameters.


GetItemOperationConfig config = new GetItemOperationConfig()
{
AttributesToGet = new List<string>() { "Id", "Title" },
};
// Pass in the configuration to the GetItem method.
// 1. Table that has only a partition key as primary key.
Table.GetItem(Primitive partitionKey, GetItemOperationConfig config);
// 2. Table that has both a partition key and a sort key.
Table.GetItem(Primitive partitionKey, Primitive sortKey, GetItemOperationConfig config);

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.

Colocación de un elemento: método Table.PutItem


El método PutItem carga la instancia de Document de entrada en la tabla. Si ya existe en la tabla un
elemento con clave principal que se especifica en el valor de Document de entrada, la operación PutItem
sustituye el elemento existente completo. El nuevo elemento es idéntico al objeto Document que ha
proporcionado al método PutItem. Si el elemento original tenía atributos adicionales, estos ya no estarán
presentes en el nuevo elemento.

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.

1. Ejecute laTable.LoadTableEl método proporciona el nombre de la tabla en la que desea colocar un


elemento.
2. Cree un objeto Document que tenga una lista de nombres de atributos y sus valores.
3. Ejecución deTable.PutItemProporcione el valorDocumentcomo parámetro.

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 table = Table.LoadTable(client, "ProductCatalog");

Versión de API 2012-08-10


282
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

var book = new Document();


book["Id"] = 101;
book["Title"] = "Book 101 Title";
book["ISBN"] = "11-11-11-11";
book["Authors"] = new List<string> { "Author 1", "Author 2" };
book["InStock"] = new DynamoDBBool(true);
book["QuantityOnHand"] = new DynamoDBNull();

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:

• List: use el constructor DynamoDBList.


• Map: use el constructor Document.

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 table = Table.LoadTable(client, "ProductCatalog");

var book = new Document();


book["Id"] = 101;

/*other attributes omitted for brevity...*/

var relatedItems = new DynamoDBList();


relatedItems.Add(341);
relatedItems.Add(472);
relatedItems.Add(649);
book.Add("RelatedItems", relatedItems);

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

Table table = Table.LoadTable(client, "ProductCatalog");

var book = new Document();


book["Id"] = 101;

/*other attributes omitted for brevity...*/

var pictures = new Document();


pictures.Add("FrontView", "http://example.com/products/101_front.jpg" );
pictures.Add("RearView", "http://example.com/products/101_rear.jpg" );

book.Add("Pictures", pictures);

Versión de API 2012-08-10


283
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

table.PutItem(book);

Estos ejemplos se basan en el elemento mostrado en Especificación de atributos de elemento al utilizar


expresiones (p. 421). El modelo de documento permite crear atributos anidados complejos, como el
atributo ProductReviews mostrado en el caso práctico.

Especificación de parámetros opcionales


Puede configurar parámetros opcionales para la operación PutItem agregando el parámetro
PutItemOperationConfig. Para obtener una lista completa de parámetros opcionales,
consulte, consultePutItem. En el siguiente ejemplo de código C# se coloca un elemento en la tabla
ProductCatalog. En él se especifica el parámetro opcional siguiente:

• 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 table = Table.LoadTable(client, "ProductCatalog");

var book = new Document();


book["Id"] = 555;
book["Title"] = "Book 555 Title";
book["Price"] = "25.00";
book["ISBN"] = "55-55-55-55";
book["Name"] = "Item 1 updated";
book["Authors"] = new List<string> { "Author x", "Author y" };
book["InStock"] = new DynamoDBBool(true);
book["QuantityOnHand"] = new DynamoDBNull();

// Create a condition expression for the optional conditional put operation.


Expression expr = new Expression();
expr.ExpressionStatement = "ISBN = :val";
expr.ExpressionAttributeValues[":val"] = "55-55-55-55";

PutItemOperationConfig config = new PutItemOperationConfig()


{
// Optional parameter.
ConditionalExpression = expr
};

table.PutItem(book, config);

Obtención de un elemento: Table.GetItem


La operación GetItem recupera un elemento como una instancia de Document. Debe proporcionar la
clave principal del elemento que desea recuperar tal y como se muestra en el siguiente ejemplo de código
C#.

Example

Table table = Table.LoadTable(client, "ProductCatalog");


Document document = table.GetItem(101); // Primary key 101.

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

Versión de API 2012-08-10


284
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

Especificación de parámetros opcionales


Puede configurar opciones adicionales para la operación GetItem agregando el parámetro
GetItemOperationConfig. Para obtener una lista completa de parámetros opcionales, consulte,
consulteGetItem. En el siguiente ejemplo de código C# se recupera un elemento de la tabla
ProductCatalog. Se especifica GetItemOperationConfig para proporcionar los parámetros
opcionales siguientes:

• El parámetro AttributesToGet para recuperar solamente los atributos especificados.


• El parámetro ConsistentRead para solicitar los valores más recientes de todos los atributos
especificados. Para obtener más información sobre la consistencia de datos, consulte Consistencia de
lectura (p. 17).

Example

Table table = Table.LoadTable(client, "ProductCatalog");

GetItemOperationConfig config = new GetItemOperationConfig()


{
AttributesToGet = new List<string>() { "Id", "Title", "Authors", "InStock",
"QuantityOnHand" },
ConsistentRead = true
};
Document doc = table.GetItem(101, config);

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:

• List— Use laAsDynamoDBListMétodo de.


• Map— Use laAsDocumentMétodo de.

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

DynamoDBList relatedItems = doc["RelatedItems"].AsDynamoDBList();

Document pictures = doc["Pictures"].AsDocument();

Eliminación de un elemento: Table.DeleteItem


La operación DeleteItem elimina un elemento de una tabla. Puede pasar la clave principal del elemento
como parámetro. O bien, si ya ha leído un elemento y tiene el objeto Document correspondiente, puede
pasarlo como parámetro al método DeleteItem, como se muestra en el siguiente ejemplo de código C#.

Versión de API 2012-08-10


285
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

Example

Table table = Table.LoadTable(client, "ProductCatalog");

// Retrieve a book (a Document instance)


Document document = table.GetItem(111);

// 1) Delete using the Document instance.


table.DeleteItem(document);

// 2) Delete using the primary key.


int partitionKey = 222;
table.DeleteItem(partitionKey)

Especificación de parámetros opcionales


Puede configurar opciones adicionales para la operación Delete agregando el parámetro
DeleteItemOperationConfig. Para obtener una lista completa de parámetros opcionales, consulte,
consulteDeleteTable. En el siguiente ejemplo de código C# se especifican los dos parámetros opcionales
siguientes:

• 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

Table table = Table.LoadTable(client, "ProductCatalog");


int partitionKey = 111;

Expression expr = new Expression();


expr.ExpressionStatement = "ISBN = :val";
expr.ExpressionAttributeValues[":val"] = "11-11-11-11";

// Specify optional parameters for Delete operation.


DeleteItemOperationConfig config = new DeleteItemOperationConfig
{
ConditionalExpression = expr,
ReturnValues = ReturnValues.AllOldAttributes // This is the only supported value when
using the document model.
};

// Delete the book.


Document d = table.DeleteItem(partitionKey, config);

Actualización de un elemento: Table.UpdateItem


La operación UpdateItem actualiza un elemento si existe. Si el elemento que tiene clave principal
especificada no se encuentra, la operación UpdateItem agrega un nuevo elemento.

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.

La acción UpdateItem se rige por las directrices siguientes:

• Si el elemento no existe, UpdateItem agrega un elemento nuevo utilizando la clave principal


especificada en la información de entrada.

Versión de API 2012-08-10


286
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

• Si el elemento existe, UpdateItem aplica las actualizaciones como se indica a continuación:


• Sustituye los valores de los atributos existentes por los valores de la actualización.
• Si un atributo que se proporciona en la información de entrada no existe, agrega un nuevo atributo al
elemento.
• Si el valor del atributo de entrada es null, elimina el atributo, en caso de que esté presente.

Note

Este nivel medioUpdateItemadmite la operaciónAddacción (verUpdateItem) compatible con la


operación DynamoDB subyacente.
Note

La operación PutItem (Colocación de un elemento: método Table.PutItem (p. 282)) también


puede llevar a cabo una actualización. Si llama a PutItem para cargar un elemento y la clave
principal ya existe, la operación PutItem sustituye el elemento completo. Si hay atributos en
el elemento existente que no se especifican en el objeto Document que se va a colocar, la
operación PutItem los eliminará. Sin embargo, UpdateItem solo actualiza 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 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.

Para eliminar un atributo, especifique que su valor es null.


3. Llame al método Table.UpdateItem y proporcione la instancia Document como parámetro de
entrada.

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 table = Table.LoadTable(client, "ProductCatalog");

var book = new Document();

// Set the attributes that you wish to update.


book["Id"] = 111; // Primary key.
// Replace the authors attribute.
book["Authors"] = new List<string> { "Author x", "Author y" };
// Add a new attribute.
book["XYZ"] = 12345;
// Delete the existing PageCount attribute.
book["PageCount"] = null;

table.Update(book);

Versión de API 2012-08-10


287
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

Especificación de parámetros opcionales


Puede configurar opciones adicionales para la operación UpdateItem agregando el parámetro
UpdateItemOperationConfig. Para obtener una lista completa de parámetros opcionales, consulte,
consulteUpdateItem.

En el siguiente ejemplo de código C# se actualiza el precio de un elemento de libro a 25. En él se


especifican los dos parámetros opcionales siguientes:

• El parámetro ConditionalExpression, que identifica el atributo Price con un valor de 20 que


prevemos que estará presente.
• El parámetro ReturnValues para solicitar que la operación UpdateItem devuelva el elemento
actualizado.

Example

Table table = Table.LoadTable(client, "ProductCatalog");


string partitionKey = "111";

var book = new Document();


book["Id"] = partitionKey;
book["Price"] = 25;

Expression expr = new Expression();


expr.ExpressionStatement = "Price = :val";
expr.ExpressionAttributeValues[":val"] = "20";

UpdateItemOperationConfig config = new UpdateItemOperationConfig()


{
ConditionalExpression = expr,
ReturnValues = ReturnValues.AllOldAttributes
};

Document d1 = table.Update(book, config);

Escritura por lotes: colocación y eliminación de varios elementos


La escritura por lotes se refiere a colocar y eliminar varios elementos en un lote. La operación permite
colocar y eliminar varios elementos de una o varias tablas con una sola llamada. A continuación se
indican los pasos que debe seguir para colocar o eliminar varios elementos en una tabla conAWS SDK
for .NETAPI de modelo de documento.

1. Cree un objeto Table ejecutando el método Table.LoadTable y proporcionando el nombre de la


tabla en la que desea llevar a cabo la operación por lotes.
2. Ejecute laCreateBatchWriteEn la instancia de la tabla que ha creado en el paso anterior y cree
unDocumentBatchWriteun objeto.
3. Use los métodos de objeto DocumentBatchWrite para especificar los documentos que desea
actualizar o eliminar.
4. Llame a laDocumentBatchWrite.Executepara ejecutar la operación por lotes.

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,

Versión de API 2012-08-10


288
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

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.

Table productCatalog = Table.LoadTable(client, "ProductCatalog");


var batchWrite = productCatalog.CreateBatchWrite();

var book1 = new Document();


book1["Id"] = 902;
book1["Title"] = "My book1 in batch write using .NET document model";
book1["Price"] = 10;
book1["Authors"] = new List<string> { "Author 1", "Author 2", "Author 3" };
book1["InStock"] = new DynamoDBBool(true);
book1["QuantityOnHand"] = 5;

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:

• Colocar un nuevo elemento en el elemento de la tabla Forum.


• Colocar un elemento en la tabla Thread y eliminar un elemento de la misma tabla.

// 1. Specify item to add in the Forum table.


Table forum = Table.LoadTable(client, "Forum");
var forumBatchWrite = forum.CreateBatchWrite();

var forum1 = new Document();


forum1["Name"] = "Test BatchWrite Forum";
forum1["Threads"] = 0;
forumBatchWrite.AddDocumentToPut(forum1);

// 2a. Specify item to add in the Thread table.


Table thread = Table.LoadTable(client, "Thread");
var threadBatchWrite = thread.CreateBatchWrite();

Versión de API 2012-08-10


289
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

var thread1 = new Document();


thread1["ForumName"] = "Amazon S3 forum";
thread1["Subject"] = "My sample question";
thread1["Message"] = "Message text";
thread1["KeywordTags"] = new List<string>{ "Amazon S3", "Bucket" };
threadBatchWrite.AddDocumentToPut(thread1);

// 2b. Specify item to delete from the Thread table.


threadBatchWrite.AddKeyToDelete("someForumName", "someSubject");

// 3. Create multi-table batch.


var superBatch = new MultiTableDocumentBatchWrite();
superBatch.AddBatch(forumBatchWrite);
superBatch.AddBatch(threadBatchWrite);

superBatch.Execute();

Ejemplo: Operaciones CRUD mediante elAWS SDK


for .NETModelo de documento
En el siguiente ejemplo de código C# se realizan las siguientes acciones:

• Cree un elemento de libro en la tabla ProductCatalog.


• Recupera el elemento de libro.
• Actualiza el elemento de libro. En el ejemplo de código se muestra una actualización normal que agrega
nuevos atributos y actualiza los existentes. También se muestra una actualización condicional que
actualiza el precio del libro solamente si el valor del precio actual es el especificado en el código.
• Elimina el elemento de libro.

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
{

Versión de API 2012-08-10


290
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();


private static string tableName = "ProductCatalog";
// The sample uses the following id PK value to add book item.
private static int sampleBookId = 555;

static void Main(string[] args)


{
try
{
Table productCatalog = Table.LoadTable(client, tableName);
CreateBookItem(productCatalog);
RetrieveBook(productCatalog);
// Couple of sample updates.
UpdateMultipleAttributes(productCatalog);
UpdateBookPriceConditionally(productCatalog);

// 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); }
}

// Creates a sample book item.


private static void CreateBookItem(Table productCatalog)
{
Console.WriteLine("\n*** Executing CreateBookItem() ***");
var book = new Document();
book["Id"] = sampleBookId;
book["Title"] = "Book " + sampleBookId;
book["Price"] = 19.99;
book["ISBN"] = "111-1111111111";
book["Authors"] = new List<string> { "Author 1", "Author 2", "Author 3" };
book["PageCount"] = 500;
book["Dimensions"] = "8.5x11x.5";
book["InPublication"] = new DynamoDBBool(true);
book["InStock"] = new DynamoDBBool(false);
book["QuantityOnHand"] = 0;

productCatalog.PutItem(book);
}

private static void RetrieveBook(Table productCatalog)


{
Console.WriteLine("\n*** Executing RetrieveBook() ***");
// Optional configuration.
GetItemOperationConfig config = new GetItemOperationConfig
{
AttributesToGet = new List<string> { "Id", "ISBN", "Title", "Authors",
"Price" },
ConsistentRead = true
};
Document document = productCatalog.GetItem(sampleBookId, config);
Console.WriteLine("RetrieveBook: Printing book retrieved...");
PrintDocument(document);
}

private static void UpdateMultipleAttributes(Table productCatalog)


{
Console.WriteLine("\n*** Executing UpdateMultipleAttributes() ***");
Console.WriteLine("\nUpdating multiple attributes....");
int partitionKey = sampleBookId;

Versión de API 2012-08-10


291
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

var book = new Document();


book["Id"] = partitionKey;
// List of attribute updates.
// The following replaces the existing authors list.
book["Authors"] = new List<string> { "Author x", "Author y" };
book["newAttribute"] = "New Value";
book["ISBN"] = null; // Remove it.

// 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);
}

private static void UpdateBookPriceConditionally(Table productCatalog)


{
Console.WriteLine("\n*** Executing UpdateBookPriceConditionally() ***");

int partitionKey = sampleBookId;

var book = new Document();


book["Id"] = partitionKey;
book["Price"] = 29.99;

// For conditional price update, creating a condition expression.


Expression expr = new Expression();
expr.ExpressionStatement = "Price = :val";
expr.ExpressionAttributeValues[":val"] = 19.00;

// 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);
}

private static void DeleteBook(Table productCatalog)


{
Console.WriteLine("\n*** Executing DeleteBook() ***");
// Optional configuration.
DeleteItemOperationConfig config = new DeleteItemOperationConfig
{
// Return the deleted item.
ReturnValues = ReturnValues.AllOldAttributes
};
Document document = productCatalog.DeleteItem(sampleBookId, config);
Console.WriteLine("DeleteBook: Printing deleted just deleted...");
PrintDocument(document);
}

private static void PrintDocument(Document updatedDocument)


{
foreach (var attribute in updatedDocument.GetAttributeNames())
{
string stringValue = null;
var value = updatedDocument[attribute];

Versión de API 2012-08-10


292
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

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

Ejemplo: Operaciones Batch utilizandoAWS SDK for .NETAPI de


modelo de documento
Temas
• Ejemplo: Escritura Batch utilizandoAWS SDK for .NETModelo de documento (p. 293)

Ejemplo: Escritura Batch utilizandoAWS SDK for .NETModelo de documento


En el siguiente ejemplo de código C# se ilustran las operaciones de escritura por lotes en una tabla y en
varias. En el ejemplo se realizan las siguientes tareas:

• 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

Versión de API 2012-08-10


293
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

{
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); }

Console.WriteLine("To continue, press Enter");


Console.ReadLine();
}

private static void SingleTableBatchWrite()


{
Table productCatalog = Table.LoadTable(client, "ProductCatalog");
var batchWrite = productCatalog.CreateBatchWrite();

var book1 = new Document();


book1["Id"] = 902;
book1["Title"] = "My book1 in batch write using .NET helper classes";
book1["ISBN"] = "902-11-11-1111";
book1["Price"] = 10;
book1["ProductCategory"] = "Book";
book1["Authors"] = new List<string> { "Author 1", "Author 2", "Author 3" };
book1["Dimensions"] = "8.5x11x.5";
book1["InStock"] = new DynamoDBBool(true);
book1["QuantityOnHand"] = new DynamoDBNull(); //Quantity is unknown at this
time

batchWrite.AddDocumentToPut(book1);
// Specify delete item using overload that takes PK.
batchWrite.AddKeyToDelete(12345);
Console.WriteLine("Performing batch write in SingleTableBatchWrite()");
batchWrite.Execute();
}

private static void MultiTableBatchWrite()


{
// 1. Specify item to add in the Forum table.
Table forum = Table.LoadTable(client, "Forum");
var forumBatchWrite = forum.CreateBatchWrite();

var forum1 = new Document();


forum1["Name"] = "Test BatchWrite Forum";
forum1["Threads"] = 0;
forumBatchWrite.AddDocumentToPut(forum1);

// 2a. Specify item to add in the Thread table.


Table thread = Table.LoadTable(client, "Thread");
var threadBatchWrite = thread.CreateBatchWrite();

var thread1 = new Document();


thread1["ForumName"] = "S3 forum";
thread1["Subject"] = "My sample question";
thread1["Message"] = "Message text";
thread1["KeywordTags"] = new List<string> { "S3", "Bucket" };
threadBatchWrite.AddDocumentToPut(thread1);

// 2b. Specify item to delete from the Thread table.


threadBatchWrite.AddKeyToDelete("someForumName", "someSubject");

Versión de API 2012-08-10


294
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

// 3. Create multi-table batch.


var superBatch = new MultiTableDocumentBatchWrite();
superBatch.AddBatch(forumBatchWrite);
superBatch.AddBatch(threadBatchWrite);
Console.WriteLine("Performing batch write in MultiTableBatchWrite()");
superBatch.Execute();
}
}
}

Consultar tablas en DynamoDB mediante el comandoAWS SDK


for .NETModelo de documento
Temas
• Método Table.Query delAWS SDK for .NET (p. 295)
• Método Table.Scan delAWS SDK for .NET (p. 300)

Método Table.Query delAWS SDK for .NET


El método Query permite consultar las tablas. Solo se pueden consultar las tablas cuya clave principal
es compuesta (con clave de partición y clave de orden). Si la clave principal de la tabla solamente consta
de la clave de partición, no se admite la operación Query. De forma predeterminada, Query lleva a
cabo internamente consultas consistentes finales. Para obtener más información sobre el modelo de
consistencia, consulte Consistencia de lectura (p. 17).

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

Query(Primitive partitionKey, RangeFilter Filter);

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

string tableName = "Reply";


Table table = Table.LoadTable(client, tableName);

DateTime twoWeeksAgoDate = DateTime.UtcNow - TimeSpan.FromDays(15);


RangeFilter filter = new RangeFilter(QueryOperator.GreaterThan, twoWeeksAgoDate);
Search search = table.Query("DynamoDB Thread 2", filter);

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

List<Document> documentSet = new List<Document>();


do
{

Versión de API 2012-08-10


295
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

documentSet = search.GetNextSet();
foreach (var document in documentSet)
PrintDocument(document);
} while (!search.IsDone);

private static void PrintDocument(Document document)


{
Console.WriteLine();
foreach (var attribute in document.GetAttributeNames())
{
string stringValue = null;
var value = document[attribute];
if (value is Primitive)
stringValue = value.AsPrimitive().Value;
else if (value is PrimitiveList)
stringValue = string.Join(",", (from primitive
in value.AsPrimitiveList().Entries
select primitive.Value).ToArray());
Console.WriteLine("{0} - {1}", attribute, stringValue);
}
}

Especificación de parámetros opcionales


También puede especificar parámetros opcionales para Query, tales como una lista de atributos que
recuperar, la lectura de consistencia alta, el tamaño de página y el número de elementos devueltos
por página. Para obtener una lista completa de parámetros, consulteConsulta. Para especificar
parámetros opcionales, debe usar la siguiente sobrecarga en la que se proporciona el objeto
QueryOperationConfig.

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

Table table = Table.LoadTable(client, "Reply");


DateTime twoWeeksAgoDate = DateTime.UtcNow - TimeSpan.FromDays(15);
QueryOperationConfig config = new QueryOperationConfig()
{
HashKey = "DynamoDB Thread 2", //Partition key
AttributesToGet = new List<string>
{ "Subject", "ReplyDateTime", "PostedBy" },
ConsistentRead = true,
Filter = new RangeFilter(QueryOperator.GreaterThan, twoWeeksAgoDate)
};

Search search = table.Query(config);

Ejemplo: Consulta con el método Table.Query


En el siguiente ejemplo de código C# se utiliza laTable.Querypara ejecutar las siguientes consultas de
ejemplo.

• Las siguientes consultas se ejecutan en laReplyTabla de.

Versión de API 2012-08-10


296
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

• Buscar las respuestas a una conversación del foro publicadas en los últimos 15 días.

Esta consulta se ejecuta dos veces. En la primera llamada a Table.Query, en el ejemplo se


proporcionan solo los parámetros de consulta obligatorios. En la segunda llamada a Table.Query,
se proporcionan parámetros de consulta opcionales para solicitar la lectura de consistencia alta y la
lista de atributos que hay que recuperar.
• Buscar las respuestas a una conversación del foro publicadas durante un periodo determinado.

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

static void Main(string[] args)


{
try
{
// Query examples.
Table replyTable = Table.LoadTable(client, "Reply");
string forumName = "Amazon DynamoDB";
string threadSubject = "DynamoDB Thread 2";
FindRepliesInLast15Days(replyTable, forumName, threadSubject);
FindRepliesInLast15DaysWithConfig(replyTable, forumName, threadSubject);
FindRepliesPostedWithinTimePeriod(replyTable, forumName, threadSubject);

// Get Example.
Table productCatalogTable = Table.LoadTable(client, "ProductCatalog");
int productId = 101;

Versión de API 2012-08-10


297
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

GetProduct(productCatalogTable, productId);

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

private static void GetProduct(Table tableName, int productId)


{
Console.WriteLine("*** Executing GetProduct() ***");
Document productDocument = tableName.GetItem(productId);
if (productDocument != null)
{
PrintDocument(productDocument);
}
else
{
Console.WriteLine("Error: product " + productId + " does not exist");
}
}

private static void FindRepliesInLast15Days(Table table, string forumName, string


threadSubject)
{
string Attribute = forumName + "#" + threadSubject;

DateTime twoWeeksAgoDate = DateTime.UtcNow - TimeSpan.FromDays(15);


QueryFilter filter = new QueryFilter("Id", QueryOperator.Equal, partitionKey);
filter.AddCondition("ReplyDateTime", QueryOperator.GreaterThan,
twoWeeksAgoDate);

// Use Query overloads that takes the minimum required query parameters.
Search search = table.Query(filter);

List<Document> documentSet = new List<Document>();


do
{
documentSet = search.GetNextSet();
Console.WriteLine("\nFindRepliesInLast15Days: printing ............");
foreach (var document in documentSet)
PrintDocument(document);
} while (!search.IsDone);
}

private static void FindRepliesPostedWithinTimePeriod(Table table, string


forumName, string threadSubject)
{
DateTime startDate = DateTime.UtcNow.Subtract(new TimeSpan(21, 0, 0, 0));
DateTime endDate = DateTime.UtcNow.Subtract(new TimeSpan(1, 0, 0, 0));

QueryFilter filter = new QueryFilter("Id", QueryOperator.Equal, forumName + "#"


+ threadSubject);
filter.AddCondition("ReplyDateTime", QueryOperator.Between, startDate,
endDate);

QueryOperationConfig config = new QueryOperationConfig()


{
Limit = 2, // 2 items/page.
Select = SelectValues.SpecificAttributes,
AttributesToGet = new List<string> { "Message",
"ReplyDateTime",
"PostedBy" },
ConsistentRead = true,

Versión de API 2012-08-10


298
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

Filter = filter
};

Search search = table.Query(config);

List<Document> documentList = new List<Document>();

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

private static void FindRepliesInLast15DaysWithConfig(Table table, string


forumName, string threadName)
{
DateTime twoWeeksAgoDate = DateTime.UtcNow - TimeSpan.FromDays(15);
QueryFilter filter = new QueryFilter("Id", QueryOperator.Equal, forumName + "#"
+ threadName);
filter.AddCondition("ReplyDateTime", QueryOperator.GreaterThan,
twoWeeksAgoDate);
// You are specifying optional parameters so use QueryOperationConfig.
QueryOperationConfig config = new QueryOperationConfig()
{
Filter = filter,
// Optional parameters.
Select = SelectValues.SpecificAttributes,
AttributesToGet = new List<string> { "Message", "ReplyDateTime",
"PostedBy" },
ConsistentRead = true
};

Search search = table.Query(config);

List<Document> documentSet = new List<Document>();


do
{
documentSet = search.GetNextSet();
Console.WriteLine("\nFindRepliesInLast15DaysWithConfig:
printing ............");
foreach (var document in documentSet)
PrintDocument(document);
} while (!search.IsDone);
}

private static void PrintDocument(Document document)


{
// count++;
Console.WriteLine();
foreach (var attribute in document.GetAttributeNames())
{
string stringValue = null;
var value = document[attribute];
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);

Versión de API 2012-08-10


299
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

}
}
}
}

Método Table.Scan delAWS SDK for .NET


El método Scan lleva a cabo un examen de toda la tabla. Ofrece dos sobrecargas. El único parámetro que
el método Scan requiere es el filtro de examen, que puede proporcionar mediante la sobrecarga siguiente.

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

Thread(Subject, Message, ForumId, Tags, LastPostedDateTime, .... )

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

string tableName = "Thread";


Table ThreadTable = Table.LoadTable(client, tableName);

ScanFilter scanFilter = new ScanFilter();


scanFilter.AddCondition("ForumId", ScanOperator.Equal, 101);
scanFilter.AddCondition("Tags", ScanOperator.Contains, "sortkey");

Search search = ThreadTable.Scan(scanFilter);

Especificación de parámetros opcionales

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.

Versión de API 2012-08-10


300
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

Example

string tableName = "Thread";


Table ThreadTable = Table.LoadTable(client, tableName);

ScanFilter scanFilter = new ScanFilter();


scanFilter.AddCondition("ForumId", ScanOperator.Equal, forumId);
scanFilter.AddCondition("Tags", ScanOperator.Contains, "sortkey");

ScanOperationConfig config = new ScanOperationConfig()


{
AttributesToGet = new List<string> { "Subject", "Message" } ,
Filter = scanFilter
};

Search search = ThreadTable.Scan(config);

Ejemplo: Análisis con el método Table.Scan

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.

• Table.Scan, que acepta el objeto ScanFilter como parámetro.

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.

Debe usar el parámetro ScanOperationConfig si desea pasar parámetros opcionales al método


Scan.

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

Versión de API 2012-08-10


301
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de documento

static void Main(string[] args)


{
Table productCatalogTable = Table.LoadTable(client, "ProductCatalog");
// Scan example.
FindProductsWithNegativePrice(productCatalogTable);
FindProductsWithNegativePriceWithConfig(productCatalogTable);

Console.WriteLine("To continue, press Enter");


Console.ReadLine();
}

private static void FindProductsWithNegativePrice(Table productCatalogTable)


{
// Assume there is a price error. So we scan to find items priced < 0.
ScanFilter scanFilter = new ScanFilter();
scanFilter.AddCondition("Price", ScanOperator.LessThan, 0);

Search search = productCatalogTable.Scan(scanFilter);

List<Document> documentList = new List<Document>();


do
{
documentList = search.GetNextSet();
Console.WriteLine("\nFindProductsWithNegativePrice:
printing ............");
foreach (var document in documentList)
PrintDocument(document);
} while (!search.IsDone);
}

private static void FindProductsWithNegativePriceWithConfig(Table


productCatalogTable)
{
// Assume there is a price error. So we scan to find items priced < 0.
ScanFilter scanFilter = new ScanFilter();
scanFilter.AddCondition("Price", ScanOperator.LessThan, 0);

ScanOperationConfig config = new ScanOperationConfig()


{
Filter = scanFilter,
Select = SelectValues.SpecificAttributes,
AttributesToGet = new List<string> { "Title", "Id" }
};

Search search = productCatalogTable.Scan(config);

List<Document> documentList = new List<Document>();


do
{
documentList = search.GetNextSet();
Console.WriteLine("\nFindProductsWithNegativePriceWithConfig:
printing ............");
foreach (var document in documentList)
PrintDocument(document);
} while (!search.IsDone);
}

private static void PrintDocument(Document document)


{
// count++;
Console.WriteLine();
foreach (var attribute in document.GetAttributeNames())
{
string stringValue = null;
var value = document[attribute];

Versión de API 2012-08-10


302
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

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

.NET: Modelo de persistencia de objetos


Temas
• Atributos de DynamoDB (p. 304)
• Clase DynamoDBContext (p. 307)
• Tipos de datos admitidos (p. 312)
• Bloqueo optimista mediante un número de versión con DynamoDB mediante elAWS SDK
for .NETModelo de persistencia de objetos (p. 313)
• Asignación de datos arbitrarios con DynamoDB mediante elAWS SDK for .NETModelo de persistencia
de objetos (p. 315)
• Operaciones Batch utilizandoAWS SDK for .NETModelo de persistencia de objetos (p. 318)
• Ejemplo: Operaciones CRUD mediante elAWS SDK for .NETModelo de persistencia de
objetos (p. 321)
• Ejemplo: Operación de escritura por lotes mediante elAWS SDK for .NETModelo de persistencia de
objetos (p. 323)
• Ejemplo: Consulta y escaneo en DynamoDB mediante la herramientaAWS SDK for .NETModelo de
persistencia de objetos (p. 327)

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

El modelo de persistencia de objetos no proporciona un API para crear, actualizar o eliminar


tablas. Solo ofrece operaciones de datos. Solo puede utilizarAWS SDK for .NETAPI de bajo nivel
para crear, actualizar y eliminar tablas. Para obtener más información, consulte Uso de tablas de
DynamoDB en .NET (p. 403).

En el siguiente ejemplo se muestra cómo funciona el modelo de persistencia de objetos. Comienza con
elProductCatalogTabla de. TieneIdcomo clave principal.

ProductCatalog(Id, ...)

Supongamos que tiene unBookLa claseTitle,ISBN, yAuthors. Puede asignar elBookLa


claseProductCatalogAgregar los atributos definidos por el modelo de persistencia de objetos, como se
muestra en el siguiente ejemplo de código C#.

Versión de API 2012-08-10


303
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

Example

[DynamoDBTable("ProductCatalog")]
public class Book
{
[DynamoDBHashKey]
public int Id { get; set; }

public string Title { get; set; }


public int ISBN { get; set; }

[DynamoDBProperty("Authors")]
public List<string> BookAuthors { get; set; }

[DynamoDBIgnore]
public string CoverPage { get; set; }
}

En el ejemplo anterior, elDynamoDBTableasigna el atributoBookLa claseProductCatalogTabla de.

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.

En el ejemplo anterior, elIdse asigna a la clave principal con el mismo nombre, y la


propiedadBookAuthorsmapas de propiedades a laAuthorsAtributo deProductCatalogTabla de.
• Mapeo predeterminado: de forma predeterminada, el modelo de persistencia de objetos mapea las
propiedades de clase a los atributos con el mismo nombre de la tabla.

En el ejemplo anterior, las propiedadesTitleyISBNMapee a los atributos con el mismo nombre en


laProductCatalogTabla de.

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.

Versión de API 2012-08-10


304
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

Note

En los atributos siguientes, solo son obligatorios DynamoDBTable y DynamoDBHashKey.

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.

En el siguiente ejemplo de código C# se asigna elBookLa claseProductCatalogy la tablaIdA la clave de


partición de clave principal de la tabla.

[DynamoDBTable("ProductCatalog")]
public class Book {
[DynamoDBHashKey]
public int Id { get; set; }

// Additional properties go here.


}

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; }

DynamoDBContextutiliza esta información de asignación para crear elAuthorsAl guardar datos de


objetos en la tabla correspondiente.

Versión de API 2012-08-10


305
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

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 { ...}

Este atributo se puede heredar o anular.

• LaDynamoDBTableatributo se puede heredar. En el ejemplo anterior, si agrega una nueva


clase,Lead, que hereda de laDeveloper, también se asigna a la clasePeopleTabla de.
AmbosDeveloperyLeadLos objetos se almacenan en el objetoPeopleTabla de.
• LaDynamoDBTableEl atributo también se puede anular. En el siguiente ejemplo de código C#
se utiliza laManagerhereda de la claseDeveloperClase de. Sin embargo, la adición explícita de
laDynamoDBTableasigna la clase a otra tabla (Managers).

[DynamoDBTable("Managers")]
public class Manager : Developer { ...}

Puede agregar el parámetro opcional,LowerCamelCasePropertiesPara solicitar que DynamoDB


cambie a minúscula la primera letra del nombre de la propiedad cuando almacene los objetos en una tabla,
como se muestra en el siguiente ejemplo de C#.

[DynamoDBTable("People", LowerCamelCaseProperties=true)]
public class Developer {

Versión de API 2012-08-10


306
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

string DeveloperName;
...}

Al guardar instancias deDeveloperclase,DynamoDBContextGuarde laDeveloperNamecomo


propiedaddeveloperName.

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.

Para recuperar los elementos de las tablas, use laExecuteBatchGet, pasando el


métodoMultiTableBatchGetObjeto como parámetro.

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.

Para escribir en tablas, utilice la herramientaExecuteBatchWrite, pasando el


métodoMultiTableBatchWriteObjeto como parámetro.

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.

Versión de API 2012-08-10


307
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

• 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

Para ejecutar esta operación en segundo plano, use el método ExecuteBatchGetAsync en su


lugar.

ExecuteBatchWrite
Escribe o elimina datos en una o varias tablas y procesa todos los objetos BatchWrite de un objeto
MultiTableBatchWrite.
Note

Para ejecutar esta operación en segundo plano, use el método ExecuteBatchWriteAsync en


su lugar.

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

Supongamos que tiene unDocumentObjeto llamadodoc, que contiene una representación


de unForumArtículo de. Para saber cómo construir este objeto, consulte la descripción de
laToDocumentmétodo más adelante en este tema.) Puede usarFromDocumentpara recuperar el
valorForumelemento de laDocumentComo se muestra en el siguiente ejemplo de código C#.

Example

forum101 = context.FromDocument<Forum>(101);

Note

Si las recetasDocumentimplementa el objetoIEnumerable, puede utilizarFromDocumentsEn


su lugar, método. Esto le permite recorrer en iteración todas las instancias de la clase en
elDocument.

Versión de API 2012-08-10


308
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

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.

Supongamos que tiene un lado del clienteReplyasignada a la claseReplyen DynamoDB. En el siguiente


ejemplo de código C# se consulta laReplyPara obtener las respuestas de las conversaciones de un
foro publicadas en los últimos 15 días. LaReplytiene una clave principal que tiene la propiedadIdy la
clave de particiónReplyDateTime: clave de ordenación. Para obtener más información acerca deReply,
consulteCreación de tablas y carga de datos para ejemplos de código en DynamoDB (p. 333).

Example

DynamoDBContext context = new DynamoDBContext(client);

string replyId = "DynamoDB#DynamoDB Thread 1"; //Partition key

Versión de API 2012-08-10


309
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

DateTime twoWeeksAgoDate = DateTime.UtcNow.Subtract(new TimeSpan(14, 0, 0, 0)); // Date to


compare.
IEnumerable<Reply> latestReplies = context.Query<Reply>(replyId, QueryOperator.GreaterThan,
twoWeeksAgoDate);

Devuelve una colección de objetos Reply.

LaQuerydevuelve un método de «carga diferida»IEnumerableColección. 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, tiene que recorrer en iteración
elIEnumerable.

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.

Si ha configurado el bloqueo optimista, la actualización solo se llevará a cabo correctamente si las


versiones del elemento del lado del cliente y del lado del servidor coinciden. 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).
Note

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

IEnumerable<Book> itemsWithWrongPrice = context.Scan<Book>(


new ScanCondition("Price", ScanOperator.LessThan, price),
new ScanCondition("ProductCategory", ScanOperator.Equal, "Book")
);

LaScandevuelve un método de «carga diferida»IEnumerableColección. 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, solo tiene que recorrer en iteración
elIEnumerable.

Por motivos de desempeño, debe consultar las tablas y evitar examinarlas.

Versión de API 2012-08-10


310
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

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

DynamoDBContext context = new DynamoDBContext(client);

Forum forum101 = context.Load<Forum>(101); // Retrieve a forum by primary key.


Document doc = context.ToDocument<Forum>(forum101);

Especificación de parámetros opcionales para DynamoDBContext


Cuando se utiliza el modelo de persistencia de objetos, es posible especificar los siguientes parámetros
opcionales para la clase DynamoDBContext.

• ConsistentRead—Cuando se recuperan datos utilizando la herramientaLoad,Query, o bienScan,


puede agregar este parámetro opcional para solicitar los valores más recientes de los datos.
• IgnoreNullValues—Este parámetro informaDynamoDBContextpara pasar por alto los valores null
de los atributos durante unSave. Si este parámetro es false (o, si no se ha establecido), entonces un
valor null se interpretará como una directiva de eliminar el atributo de que se trate.
• SkipVersionCheck—Este parámetro informaDynamoDBContextNo comparar versiones al guardar
o eliminar un 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).
• TableNamePrefix—Prefija todos los nombres de tablas con una cadena específica. Si este parámetro
es null (o si no se ha establecido), no se utilizará ningún prefijo.

En el siguiente ejemplo de C# se crea unaDynamoDBContextEspecifique dos de los parámetros


opcionales anteriores.

Example

AmazonDynamoDBClient client = new AmazonDynamoDBClient();


...
DynamoDBContext context =
new DynamoDBContext(client, new DynamoDBContextConfig { ConsistentRead = true,
SkipVersionCheck = true});

DynamoDBContextincluye estos parámetros opcionales con cada solicitud que se envía utilizando este
contexto.

En lugar de establecer estos parámetros en elDynamoDBContext, puede especificarlos para las


operaciones individuales que ejecute utilizandoDynamoDBContextComo se muestra en el siguiente

Versión de API 2012-08-10


311
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

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

AmazonDynamoDBClient client = new AmazonDynamoDBClient();


...
DynamoDBContext context = new DynamoDBContext(client);
Book bookItem = context.Load<Book>(productId,new DynamoDBContextConfig{ ConsistentRead =
true, SkipVersionCheck = true });

En este caso,DynamoDBContextincluye estos parámetros solo cuando se envía elGetrequest.

Tipos de datos admitidos


El modelo de persistencia de objetos admite un conjunto de tipos de datos, colecciones y tipos de datos
arbitrarios de .NET primitivos. El modelo admite los siguientes tipos de datos primitivos.

• bool
• byte
• char
• DateTime
• decimal
• double
• float
• Int16
• Int32
• Int64
• SByte
• string
• UInt16
• UInt32
• UInt64

El modelo de persistencia de objetos también admite los tipos de colección


de .NET.DynamoDBContextpuede convertir tipos de colección concretos y objetos CLR estándar (POCO,
por sus siglas en inglés) simples.

En la tabla siguiente se resume el mapeo de los tipos de .NET anteriores a los tipos de DynamoDB.

Tipo de .NET primitivo Tipo DynamoDB

Todos los tipos de números N (tipo Number)

Todos los tipos de cadenas S (tipo String)

MemoryStream, byte[] B (tipo Binary)

bool N0 representa false y 1 representa true.

Tipos de colección BS (tipo Binary Set), SS (tipo String Set) y NS (tipo


Number Set)

Versión de API 2012-08-10


312
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

Tipo de .NET primitivo Tipo DynamoDB

DateTime S (tipo String). LaDateTimeLos valores se


almacenan como cadenas con formato ISO-8601.

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

• 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

Bloqueo optimista mediante un número de versión con


DynamoDB mediante elAWS SDK for .NETModelo de
persistencia de objetos
La compatibilidad del modelo de persistencia de objetos con el bloqueo optimista garantiza que la versión
del elemento para la aplicación sea la misma que en el lado del servidor antes de actualizar o eliminar
el elemento. Supongamos que recupera un elemento para actualizarlo. Sin embargo, antes de que se
devuelvan las actualizaciones, otra aplicación actualiza el mismo elemento. Ahora, su aplicación tiene
una copia anticuada del elemento. Sin el bloqueo optimista, cualquier actualización que lleve a cabo
sobrescribirá la actualización efectuada por la otra aplicación.

La característica de bloqueo optimista del modelo de persistencia de objetos proporciona


elDynamoDBVersionEtiqueta que puede usar para habilitar el bloqueo optimista. Para utilizar
esta característica, se agrega una propiedad a la clase para almacenar el número de versión.
Agregue elDynamoDBVersiona la propiedad. Cuando guarde el objeto por primera vez,
elDynamoDBContextasigna un número de versión e incrementa este valor cada vez que se actualiza el
elemento.

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.

En el siguiente ejemplo de código C# se define unBookClase con atributos de persistencia de objetos


que la mapean alProductCatalogTabla de. La propiedad VersionNumber de la clase asociada con el
atributo DynamoDBVersion almacena el valor del número de versió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; }

Versión de API 2012-08-10


313
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

[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?).

El bloqueo optimista afecta a las operaciones de DynamoDBContext como se indica a continuación:

• Para un elemento nuevo,DynamoDBContextAsigna el número de versión inicial 0. Si recupera un


elemento existente, actualiza una o varias de sus propiedades e intenta guardar los cambios, la
operación de almacenamiento solamente se llevará a cabo si el número de versión del lado del cliente
coincide con el número de versión del lado del servidor.DynamoDBContextincrementa el número de
versión. No es necesario establecer el número de versión.
• LaDeleteEl método proporciona sobrecargas que pueden tomar un valor de clave principal o un objeto
como parámetro, como se muestra en el siguiente ejemplo de código C#.

Example

DynamoDBContext context = new DynamoDBContext(client);


...
// Load a book.
Book book = context.Load<ProductCatalog>(111);
// Do other operations.
// Delete 1 - Pass in the book object.
context.Delete<ProductCatalog>(book);

// Delete 2 - Pass in the Id (primary key)


context.Delete<ProductCatalog>(222);

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.

Deshabilitación del bloqueo optimista


Para deshabilitar el bloqueo optimista, se usa laSkipVersionCheckpropiedad de configuración.
Puede establecer esta propiedad al crearDynamoDBContext. En este caso, el bloqueo optimista
está deshabilitado para todas las solicitudes que se realicen utilizando el contexto. Para obtener más
información, consulte Especificación de parámetros opcionales para DynamoDBContext (p. 311).

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

DynamoDBContext context = new DynamoDBContext(client);


// Load a book.

Versión de API 2012-08-10


314
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

Book book = context.Load<ProductCatalog>(111);


...
// Delete the book.
context.Delete<Book>(book, new DynamoDBContextConfig { SkipVersionCheck = true });

Asignación de datos arbitrarios con DynamoDB mediante elAWS


SDK for .NETModelo de persistencia de objetos
Además de los tipos de.NET admitidos (consulteTipos de datos admitidos (p. 312)), puede utilizar tipos
de la aplicación para los cuales no exista un mapeo directo a los tipos de Amazon DynamoDB. El modelo
de persistencia de objetos es compatible con el almacenamiento de datos de tipos arbitrarios, siempre
y cuando se proporcione el convertidor requerido para convertir los datos del tipo arbitrario al tipo de
DynamoDB y viceversa. El código del convertidor transforma los datos tanto al guardar como al cargar los
objetos.

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.

En el siguiente ejemplo de código C# se define unBookLa claseId,Title,ISBN, yDimension.


LaDimensiones de la propiedadDimensionTypeDescribeHeight,Width, yThickness. El código
de ejemplo proporciona los métodos del convertidorToEntryyFromEntrypara convertir datos
entre elDimensionTypey los tipos de cadena de DynamoDB. Por ejemplo, al guardar unBook, el
convertidor crea un libroDimensioncomo «8.5x11x.05". Cuando recupera un libro, convierte la cadena a
unaDimensionTypeinstancia.

En el ejemplo se asigna elBookAl tipoProductCatalogTabla de. Guarda una muestraBookUna instancia,


la recupera, actualiza sus dimensiones y guarda la versión actualizada delBookde nuevo.

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

Versión de API 2012-08-10


315
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();

static void Main(string[] args)


{
try
{
DynamoDBContext context = new DynamoDBContext(client);

// 1. Create a book.
DimensionType myBookDimensions = new DimensionType()
{
Length = 8M,
Height = 11M,
Thickness = 0.5M
};

Book myBook = new Book


{
Id = 501,
Title = "AWS SDK for .NET Object Persistence Model Handling Arbitrary
Data",
ISBN = "999-9999999999",
BookAuthors = new List<string> { "Author 1", "Author 2" },
Dimensions = myBookDimensions
};

context.Save(myBook);

// 2. Retrieve the book.


Book bookRetrieved = context.Load<Book>(501);

// 3. Update property (book dimensions).


bookRetrieved.Dimensions.Height += 1;
bookRetrieved.Dimensions.Length += 1;
bookRetrieved.Dimensions.Thickness += 0.2M;
// Update the book.
context.Save(bookRetrieved);

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("ProductCatalog")]
public class Book
{
[DynamoDBHashKey] //Partition key
public int Id
{
get; set;
}
[DynamoDBProperty]
public string Title
{
get; set;
}
[DynamoDBProperty]
public string ISBN
{
get; set;
}
// Multi-valued (set type) attribute.

Versión de API 2012-08-10


316
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

[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;
}
}

public class DimensionType


{
public decimal Length
{
get; set;
}
public decimal Height
{
get; set;
}
public decimal Thickness
{
get; set;
}
}

// Converts the complex type DimensionType to string and vice-versa.


public class DimensionTypeConverter : IPropertyConverter
{
public DynamoDBEntry ToEntry(object value)
{
DimensionType bookDimensions = value as DimensionType;
if (bookDimensions == null) throw new ArgumentOutOfRangeException();

string data = string.Format("{1}{0}{2}{0}{3}", " x ",


bookDimensions.Length, bookDimensions.Height,
bookDimensions.Thickness);

DynamoDBEntry entry = new Primitive


{
Value = data
};
return entry;
}

public object FromEntry(DynamoDBEntry entry)


{
Primitive primitive = entry as Primitive;
if (primitive == null || !(primitive.Value is String) ||
string.IsNullOrEmpty((string)primitive.Value))
throw new ArgumentOutOfRangeException();

string[] data = ((string)(primitive.Value)).Split(new string[] { " x " },


StringSplitOptions.None);
if (data.Length != 3) throw new ArgumentOutOfRangeException();

DimensionType complexData = new DimensionType


{
Length = Convert.ToDecimal(data[0]),
Height = Convert.ToDecimal(data[1]),
Thickness = Convert.ToDecimal(data[2])
};
return complexData;

Versión de API 2012-08-10


317
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

}
}
}

Operaciones Batch utilizandoAWS SDK for .NETModelo de


persistencia de objetos
Escritura Batch: Colocación y eliminación de varios elementos
Para colocar o eliminar varios objetos en una tabla en una única solicitud, haga lo siguiente:

• Ejecute laCreateBatchWriteMétodo deDynamoDBContext, y cree una instancia


deBatchWriteClase de.
• Especifique los elementos que desea colocar o eliminar.
• Para colocar uno o varios elementos, utilice el método AddPutItem o AddPutItems.
• Para eliminar uno o varios elementos, puede especificar la clave principal del elemento o un objeto
del lado del cliente mapeado al elemento que desea eliminar. Utilice los métodos AddDeleteItem,
AddDeleteItems y AddDeleteKey para especificar la lista de elementos que desea eliminar.
• Llame al método BatchWrite.Execute para colocar y eliminar en la tabla todos los elementos
especificados.

Note

Cuando se utiliza el modelo de persistencia de objetos, se puede especificar cualquier cantidad de


operaciones en un lote. No obstante, tenga en cuenta que Amazon 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 el API
detecta que la solicitud de escritura por lotes ha superado el número permitido de solicitudes de
escritura o la carga de HTTP máxima permitida, divide el lote en varios lotes de menor tamaño.
Además, si una respuesta a una escritura por lotes devuelve elementos sin procesar, el API
envía automáticamente otra solicitud de escritura por lotes con esos elementos que no se han
procesado.

Supongamos que ha definido una clase C #Bookque se asigna a la claseProductCatalogen


DynamoDB. En el siguiente ejemplo de código C# se utiliza laBatchWriteObjeto para cargar dos
elementos y eliminar un elemento de laProductCatalogTabla de.

Example

DynamoDBContext context = new DynamoDBContext(client);


var bookBatch = context.CreateBatchWrite<Book>();

// 1. Specify two books to add.


Book book1 = new Book
{
Id = 902,
ISBN = "902-11-11-1111",
ProductCategory = "Book",
Title = "My book3 in batch write"
};
Book book2 = new Book
{
Id = 903,
ISBN = "903-11-11-1111",
ProductCategory = "Book",
Title = "My book4 in batch write"
};

Versión de API 2012-08-10


318
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

bookBatch.AddPutItems(new List<Book> { book1, book2 });

// 2. Specify one book to delete.


bookBatch.AddDeleteKey(111);

bookBatch.Execute();

Para colocar o eliminar objetos de varias tablas, haga lo siguiente:

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

Supongamos que ha definidoForumyThreadC # que se asignan a la claseForumyThreadtablas


en DynamoDB. Además, supongamos que elThreadtiene habilitado el control de versiones. Dado
que el control de versiones no se admite en las operaciones por lotes, es preciso deshabilitarlo
de forma explícita, tal y como se muestra en el siguiente ejemplo de código C#. Este ejemplo
usaMultiTableBatchWritepara realizar una actualización de varias tablas.

Example

DynamoDBContext context = new DynamoDBContext(client);


// Create BatchWrite objects for each of the Forum and Thread classes.
var forumBatch = context.CreateBatchWrite<Forum>();

DynamoDBOperationConfig config = new DynamoDBOperationConfig();


config.SkipVersionCheck = true;
var threadBatch = context.CreateBatchWrite<Thread>(config);

// 1. New Forum item.


Forum newForum = new Forum
{
Name = "Test BatchWrite Forum",
Threads = 0
};
forumBatch.AddPutItem(newForum);

// 2. Specify a forum to delete by specifying its primary key.


forumBatch.AddDeleteKey("Some forum");

// 3. New Thread item.


Thread newThread = new Thread
{
ForumName = "Amazon S3 forum",
Subject = "My sample question",
KeywordTags = new List<string> { "Amazon S3", "Bucket" },
Message = "Message text"
};

threadBatch.AddPutItem(newThread);

Versión de API 2012-08-10


319
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

// Now run multi-table batch write.


var superBatch = new MultiTableBatchWrite(forumBatch, threadBatch);
superBatch.Execute();

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.

Obtención Batch: Obtención de varios elementos


Para recuperar varios elementos de una tabla en una única solicitud, haga lo siguiente:

• Cree una instancia de la clase CreateBatchGet.


• Especifique una lista de claves principales para recuperarlas.
• Llame al método Execute. La respuesta devuelve los elementos de la propiedad Results.

En el siguiente ejemplo de código C# se recuperan tres elementos delProductCatalogTabla de. Los


elementos del resultado no están necesariamente en el mismo orden en que se han especificado las
claves principales.

Example

DynamoDBContext context = new DynamoDBContext(client);


var bookBatch = context.CreateBatchGet<ProductCatalog>();
bookBatch.AddKey(101);
bookBatch.AddKey(102);
bookBatch.AddKey(103);
bookBatch.Execute();
// Process result.
Console.WriteLine(bookBatch.Results.Count);
Book book1 = bookBatch.Results[0];
Book book2 = bookBatch.Results[1];
Book book3 = bookBatch.Results[2];

Para recuperar objetos de varias tablas, haga lo siguiente:

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

En el siguiente ejemplo de código C# se recuperan varios elementos delOrderyOrderDetailutilizando la


herramientaCreateBatchGetMétodo de.

Versión de API 2012-08-10


320
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

Example

var orderBatch = context.CreateBatchGet<Order>();


orderBatch.AddKey(101);
orderBatch.AddKey(102);

var orderDetailBatch = context.CreateBatchGet<OrderDetail>();


orderDetailBatch.AddKey(101, "P1");
orderDetailBatch.AddKey(101, "P2");
orderDetailBatch.AddKey(102, "P3");
orderDetailBatch.AddKey(102, "P1");

var orderAndDetailSuperBatch = orderBatch.Combine(orderDetailBatch);


orderAndDetailSuperBatch.Execute();

Console.WriteLine(orderBatch.Results.Count);
Console.WriteLine(orderDetailBatch.Results.Count);

Order order1 = orderBatch.Results[0];


Order order2 = orderDetailBatch.Results[1];
OrderDetail orderDetail1 = orderDetailBatch.Results[0];

Ejemplo: Operaciones CRUD mediante elAWS SDK


for .NETModelo de persistencia de objetos
En el siguiente ejemplo de código C# se declara unBookLa claseId,Title,ISBN,
yAuthors. En el ejemplo se utilizan atributos de persistencia de objetos para mapear estas
propiedades a la propiedadProductCatalogen Amazon DynamoDB. A continuación, el
ejemplo usaDynamoDBContextPara ilustrar las operaciones típicas de creación, lectura,
actualización y eliminación (CRUD). En el ejemplo se crea una muestraBooky la guarda en la
instanciaProductCatalogTabla de. A continuación, recupera el elemento del libro y actualiza
suISBNyAuthors. Tenga en cuenta que la actualización sustituye la lista de autores existente. Por último,
en el ejemplo se elimina el elemento de libro.

Para obtener más información acerca deProductCatalogutilizada en este ejemplo, consulteCreació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/
*
* 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.
*/

Versión de API 2012-08-10


321
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

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

static void Main(string[] args)


{
try
{
DynamoDBContext context = new DynamoDBContext(client);
TestCRUDOperations(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); }
}

private static void TestCRUDOperations(DynamoDBContext context)


{
int bookID = 1001; // Some unique value.
Book myBook = new Book
{
Id = bookID,
Title = "object persistence-AWS SDK for.NET SDK-Book 1001",
ISBN = "111-1111111001",
BookAuthors = new List<string> { "Author 1", "Author 2" },
};

// Save the book.


context.Save(myBook);
// Retrieve the book.
Book bookRetrieved = context.Load<Book>(bookID);

// Update few properties.


bookRetrieved.ISBN = "222-2222221001";
bookRetrieved.BookAuthors = new List<string> { " Author 1", "Author x" }; //
Replace existing authors list with this.
context.Save(bookRetrieved);

// Retrieve the updated book. This time add the optional ConsistentRead
parameter using DynamoDBContextConfig object.
Book updatedBook = context.Load<Book>(bookID, new DynamoDBContextConfig
{
ConsistentRead = true
});

// Delete the book.


context.Delete<Book>(bookID);
// Try to retrieve deleted book. It should return null.
Book deletedBook = context.Load<Book>(bookID, new DynamoDBContextConfig
{
ConsistentRead = true
});
if (deletedBook == null)
Console.WriteLine("Book is deleted");
}
}

Versión de API 2012-08-10


322
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

[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;
}
}
}

Ejemplo: Operación de escritura por lotes mediante elAWS SDK


for .NETModelo de persistencia de objetos
En el siguiente ejemplo de código C# se declaraBook,Forum,Thread, yReplyLas mapea a tablas de
Amazon DynamoDB con los atributos del modelo de persistencia de objetos.

A continuación, el ejemplo usaDynamoDBContextPara ilustrar las siguientes operaciones de escritura por


lotes:

• BatchWriteObjeto para colocar y eliminar elementos de libro de laProductCatalogTabla de.


• MultiTableBatchWritepara colocar y eliminar elementos de laForumy laThreadTabla de.

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/
*

Versión de API 2012-08-10


323
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

* 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;
using Amazon.SecurityToken;

namespace com.amazonaws.codesamples
{
class HighLevelBatchWriteItem
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();

static void Main(string[] args)


{
try
{
DynamoDBContext context = new DynamoDBContext(client);
SingleTableBatchWrite(context);
MultiTableBatchWrite(context);
}
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }

Console.WriteLine("To continue, press Enter");


Console.ReadLine();
}

private static void SingleTableBatchWrite(DynamoDBContext context)


{
Book book1 = new Book
{
Id = 902,
InPublication = true,
ISBN = "902-11-11-1111",
PageCount = "100",
Price = 10,
ProductCategory = "Book",
Title = "My book3 in batch write"
};
Book book2 = new Book
{
Id = 903,
InPublication = true,
ISBN = "903-11-11-1111",
PageCount = "200",
Price = 10,
ProductCategory = "Book",
Title = "My book4 in batch write"
};

var bookBatch = context.CreateBatchWrite<Book>();


bookBatch.AddPutItems(new List<Book> { book1, book2 });

Console.WriteLine("Performing batch write in SingleTableBatchWrite().");


bookBatch.Execute();
}

private static void MultiTableBatchWrite(DynamoDBContext context)


{
// 1. New Forum item.
Forum newForum = new Forum

Versión de API 2012-08-10


324
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

{
Name = "Test BatchWrite Forum",
Threads = 0
};
var forumBatch = context.CreateBatchWrite<Forum>();
forumBatch.AddPutItem(newForum);

// 2. New Thread item.


Thread newThread = new Thread
{
ForumName = "S3 forum",
Subject = "My sample question",
KeywordTags = new List<string> { "S3", "Bucket" },
Message = "Message text"
};

DynamoDBOperationConfig config = new DynamoDBOperationConfig();


config.SkipVersionCheck = true;
var threadBatch = context.CreateBatchWrite<Thread>(config);
threadBatch.AddPutItem(newThread);
threadBatch.AddDeleteKey("some partition key value", "some sort key value");

var superBatch = new MultiTableBatchWrite(forumBatch, threadBatch);


Console.WriteLine("Performing batch write in MultiTableBatchWrite().");
superBatch.Execute();
}
}

[DynamoDBTable("Reply")]
public class Reply
{
[DynamoDBHashKey] //Partition key
public string Id
{
get; set;
}

[DynamoDBRangeKey] //Sort key


public DateTime ReplyDateTime
{
get; set;
}

// Properties included implicitly.


public string Message
{
get; set;
}
// Explicit property mapping with object persistence model attributes.
[DynamoDBProperty("LastPostedBy")]
public string PostedBy
{
get; set;
}
// Property to store version number for optimistic locking.
[DynamoDBVersion]
public int? Version
{
get; set;
}
}

[DynamoDBTable("Thread")]
public class Thread
{
// PK mapping.

Versión de API 2012-08-10


325
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

[DynamoDBHashKey] //Partition key


public string ForumName
{
get; set;
}
[DynamoDBRangeKey] //Sort key
public String Subject
{
get; set;
}
// Implicit mapping.
public string Message
{
get; set;
}
public string LastPostedBy
{
get; set;
}
public int Views
{
get; set;
}
public int Replies
{
get; set;
}
public bool Answered
{
get; set;
}
public DateTime LastPostedDateTime
{
get; set;
}
// Explicit mapping (property and table attribute names are different.
[DynamoDBProperty("Tags")]
public List<string> KeywordTags
{
get; set;
}
// Property to store version number for optimistic locking.
[DynamoDBVersion]
public int? Version
{
get; set;
}
}

[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

Versión de API 2012-08-10


326
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

{
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;
}
}
}

Ejemplo: Consulta y escaneo en DynamoDB mediante la


herramientaAWS SDK for .NETModelo de persistencia de objetos
En el ejemplo de C# de esta sección se definen las clases siguientes y se mapean a las tablas de
DynamoDB. Para obtener más información sobre cómo crear 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).

• LaBookLa clase se mapea alProductCatalogTabla de.

Versión de API 2012-08-10


327
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

• Las clases Forum, Thread y Reply se mapean a las tablas del mismo nombre.

A continuación, en el ejemplo se usa para ejecutar las siguientes operaciones de consulta y


examen.DynamoDBContext.

• Obtenga un libro por Id.

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.

Para obtener instrucciones acerca de cómo crear un ejemplo funcional, consulteEjemplos 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/
*
* 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();

Versión de API 2012-08-10


328
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

static void Main(string[] args)


{
try
{
DynamoDBContext context = new DynamoDBContext(client);
// Get an item.
GetBook(context, 101);

// Sample forum and thread to test queries.


string forumName = "Amazon DynamoDB";
string threadSubject = "DynamoDB Thread 1";
// Sample queries.
FindRepliesInLast15Days(context, forumName, threadSubject);
FindRepliesPostedWithinTimePeriod(context, forumName, threadSubject);

// 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); }
}

private static void GetBook(DynamoDBContext context, int productId)


{
Book bookItem = context.Load<Book>(productId);

Console.WriteLine("\nGetBook: Printing result.....");


Console.WriteLine("Title: {0} \n No.Of threads:{1} \n No. of messages: {2}",
bookItem.Title, bookItem.ISBN, bookItem.PageCount);
}

private static void FindRepliesInLast15Days(DynamoDBContext context,


string forumName,
string threadSubject)
{
string replyId = forumName + "#" + threadSubject;
DateTime twoWeeksAgoDate = DateTime.UtcNow - TimeSpan.FromDays(15);
IEnumerable<Reply> latestReplies =
context.Query<Reply>(replyId, QueryOperator.GreaterThan, twoWeeksAgoDate);
Console.WriteLine("\nFindRepliesInLast15Days: Printing result.....");
foreach (Reply r in latestReplies)
Console.WriteLine("{0}\t{1}\t{2}\t{3}", r.Id, r.PostedBy, r.Message,
r.ReplyDateTime);
}

private static void FindRepliesPostedWithinTimePeriod(DynamoDBContext context,


string forumName,
string threadSubject)
{
string forumId = forumName + "#" + threadSubject;
Console.WriteLine("\nFindRepliesPostedWithinTimePeriod: Printing result.....");

DateTime startDate = DateTime.UtcNow - TimeSpan.FromDays(30);


DateTime endDate = DateTime.UtcNow - TimeSpan.FromDays(1);

IEnumerable<Reply> repliesInAPeriod = context.Query<Reply>(forumId,


QueryOperator.Between, startDate, endDate);
foreach (Reply r in repliesInAPeriod)
Console.WriteLine("{0}\t{1}\t{2}\t{3}", r.Id, r.PostedBy, r.Message,
r.ReplyDateTime);
}

Versión de API 2012-08-10


329
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

private static void FindProductsPricedLessThanZero(DynamoDBContext context)


{
int price = 0;
IEnumerable<Book> itemsWithWrongPrice = context.Scan<Book>(
new ScanCondition("Price", ScanOperator.LessThan, price),
new ScanCondition("ProductCategory", ScanOperator.Equal, "Book")
);
Console.WriteLine("\nFindProductsPricedLessThanZero: Printing result.....");
foreach (Book r in itemsWithWrongPrice)
Console.WriteLine("{0}\t{1}\t{2}\t{3}", r.Id, r.Title, r.Price, r.ISBN);
}
}

[DynamoDBTable("Reply")]
public class Reply
{
[DynamoDBHashKey] //Partition key
public string Id
{
get; set;
}

[DynamoDBRangeKey] //Sort key


public DateTime ReplyDateTime
{
get; set;
}

// Properties included implicitly.


public string Message
{
get; set;
}
// Explicit property mapping with object persistence model attributes.
[DynamoDBProperty("LastPostedBy")]
public string PostedBy
{
get; set;
}
// Property to store version number for optimistic locking.
[DynamoDBVersion]
public int? Version
{
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;
}

Versión de API 2012-08-10


330
Amazon DynamoDB Guía para desarrolladores
.NET: Modelo de persistencia de objetos

public string LastPostedBy


{
get; set;
}
public int Views
{
get; set;
}
public int Replies
{
get; set;
}
public bool Answered
{
get; set;
}
public DateTime LastPostedDateTime
{
get; set;
}
// Explicit mapping (property and table attribute names are different).
[DynamoDBProperty("Tags")]
public List<string> KeywordTags
{
get; set;
}
// Property to store version number for optimistic locking.
[DynamoDBVersion]
public int? Version
{
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

Versión de API 2012-08-10


331
Amazon DynamoDB Guía para desarrolladores
Ejecución de ejemplos de código

{
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;
}
}
}

Cómo ejecutar los ejemplos de código de esta guía


para desarrolladores
LaAWSLos SDK proporcionan un amplio soporte para Amazon DynamoDB en los siguientes lenguajes:

• Java
• JavaScript en el navegador
• .NET
• Node.js
• PHP
• Python
• Ruby
• C++
• Go
• Android
• iOS

Versión de API 2012-08-10


332
Amazon DynamoDB Guía para desarrolladores
Carga de ejemplos de datos

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:

• Ejemplos de código Java (p. 338)


• Ejemplos de código .NET (p. 340)

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

Creación de tablas y carga de datos para ejemplos de


código en DynamoDB
En este tutorial, utilizará la propiedadAWS Management Consolepara crear tablas en Amazon DynamoDB.
A continuación, cargará datos en ellas mediante la AWS Command Line Interface (AWS CLI).

Estas tablas y sus datos se utilizan como ejemplos en esta guía para desarrolladores.
Note

Si es un desarrollador de aplicaciones, le recomendamos que lea también laIntroducción a


DynamoDB yAWSSDK de (p. 82), que utiliza la versión descargable de DynamoDB. De este
modo, podrá aprender a usar la API de bajo nivel de DynamoDB sin tener que abonar costos de
desempeño, almacenamiento o transferencia de datos.

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)

Paso 1: Crear ejemplos de tablas


En esta sección, utilizará la propiedadAWS Management ConsolePara crear tablas en Amazon DynamoDB
en dos casos de uso sencillos.

Caso de uso 1: Catálogo de productos


Supongamos que desea almacenar información de productos en DynamoDB. Cada producto tiene sus
propios atributos diferenciados, por lo que debe almacenar información distinta sobre cada uno de estos
productos.

Puede crear una tabla ProductCatalog en la que cada elemento se identifique de forma exclusiva
mediante un único atributo numérico: Id.

Versión de API 2012-08-10


333
Amazon DynamoDB Guía para desarrolladores
Carga de ejemplos de datos

Nombre de la tabla Clave principal

ProductCatalog Clave de partición: Id (Número)

Caso de uso 2: Solicitud de foros


Supongamos que desea desarrollar una aplicación para paneles de mensajes o foros de debate.AWS
Foros de debate deRepresenta un ejemplo de una aplicación de este tipo. Los clientes pueden
interaccionar con la comunidad de desarrolladores, plantear preguntas o contestar a las publicaciones
de otros clientes. EACHAWSservicio tiene un foro específico. Cualquier usuario puede iniciar una nueva
conversación de debate publicando un mensaje en un foro. Cada conversación podría recibir cualquier
número de respuestas.

Puede modelar esta aplicación creando tres tablas: Forum, Thread y Reply.

Nombre de la tabla Clave principal

Forum Clave de partición: Name (Cadena)

Thread Clave de partición: ForumName (Cadena)

El criterio de ordenación: Subject (Cadena)

Reply Clave de partición: Id (Cadena)

El criterio de ordenación: ReplyDateTime


(Cadena)

LaReplytiene un índice secundario global denominadoPostedBy-Message-Index. Este índice facilita


las consultas de dos atributos sin clave de la tabla Reply.

Nombre de índice Clave principal

PostedBy-Message-Index Clave de partición: PostedBy (Cadena)

El criterio de ordenación: Message (Cadena)

Cree la tabla ProductCatalog


1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.
2. Seleccione Create Table (Crear tabla).
3. En la pantalla Create DynamoDB table (Crear tabla de DynamoDB), haga lo siguiente:

a. En el campo Table name (Nombre de la tabla), introduzca ProductCatalog.


b. En Primary key (Clave principal), en el campo Partition key (Clave de partición), escriba Id.
Establezca el tipo de datos en Number (Número).
4. Cuando esté conforme con los ajustes, elija Create (Crear).

Cree la tabla Forum


1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.

Versión de API 2012-08-10


334
Amazon DynamoDB Guía para desarrolladores
Carga de ejemplos de datos

2. Seleccione Create Table (Crear tabla).


3. En la pantalla Create DynamoDB table (Crear tabla de DynamoDB), haga lo siguiente:

a. En el campo Table name (Nombre de la tabla), introduzca Forum.


b. En Primary key (Clave principal), en el campo Partition key (Clave de partición), escriba Name.
Establezca el tipo de datos en String (Cadena).
4. Cuando esté conforme con los ajustes, elija Create (Crear).

Cree la tabla Thread


1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.
2. Seleccione Create Table (Crear tabla).
3. En la pantalla Create DynamoDB table (Crear tabla de DynamoDB), haga lo siguiente:

a. En el campo Table name (Nombre de la tabla), introduzca Thread.


b. En Primary key (Clave principal), haga lo siguiente:

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

Cree la tabla Reply


1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.
2. Seleccione Create Table (Crear tabla).
3. En la pantalla Create DynamoDB table (Crear tabla de DynamoDB), haga lo siguiente:

a. En el campo Table name (Nombre de la tabla), introduzca Reply.


b. En Primary key (Clave principal), haga lo siguiente:

• 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:

• En Primary key (Clave principal), haga lo siguiente:


• En el campo Partition key (Clave de partición), escriba PostedBy. 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 Message. Establezca el tipo de
datos en String (Cadena).
• En el campo Index name (Nombre del índice), introduzca PostedBy-Message-Index.
• Establezca Projected attributes (Atributos proyectados) en All (Todos).

Versión de API 2012-08-10


335
Amazon DynamoDB Guía para desarrolladores
Carga de ejemplos de datos

• Elija Add index.


4. Cuando esté conforme con los ajustes, elija Create (Crear).

Paso 2: Cargar los datos en las tablas


En este paso, vamos a cargar ejemplos de datos en las tablas que ha creado. Podría introducir los datos
manualmente en la consola de Amazon DynamoDB. No obstante, para ahorrar tiempo, en su lugar utilice la
AWS Command Line Interface (AWS CLI).
Note

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": {}
}

Descargue el archivo comprimido con los ejemplos de datos


1. Descargue el ejemplo de archivo comprimido de datos (sampledata.zip) en este enlace:

• sampledata.zip
2. Extraiga los archivos de datos .json del archivo comprimido.
3. Copie los archivos .json en el directorio actual.

Cargue los ejemplos de datos en las tablas de DynamoDB


1. Para cargar datos en la tabla ProductCatalog, escriba el siguiente comando:

aws dynamodb batch-write-item --request-items file://ProductCatalog.json


2. Para cargar datos en la tabla Forum, escriba el siguiente comando:

aws dynamodb batch-write-item --request-items file://Forum.json


3. Para cargar datos en la tabla Thread, escriba el siguiente comando:

aws dynamodb batch-write-item --request-items file://Thread.json


4. Para cargar datos en la tabla Reply, escriba el siguiente comando:

aws dynamodb batch-write-item --request-items file://Reply.json

Compruebe la carga de datos


Puede utilizar la AWS Management Console para comprobar los datos que ha cargado en las tablas.

Para comprobar los datos desde la AWS Management Console

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.


2. En el panel de navegación, elija Tables (Tablas).
3. En la lista de tablas, elija ProductCatalog.

Versión de API 2012-08-10


336
Amazon DynamoDB Guía para desarrolladores
Carga de ejemplos de datos

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

Paso 3: Consulta de los datos


En este paso, vamos a usar la consola de Amazon DynamoDB para probar algunas consultas sencillas en
las tablas que hemos creado.

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.


2. En el panel de navegación, elija Tables (Tablas).
3. En la lista de tablas, elija Reply.
4. Elija la pestaña Items (Elementos) para ver los datos que ha cargado en la tabla.
5. Elija el enlace de filtrado de datos, situado justo debajo del botón Create item (Crear elemento).

Al elegir el vínculo, la consola muestra un panel de filtrado de datos.

6. En el panel de filtrado de datos, haga lo siguiente:

a. Cambie la operación de Scan (Examen) a Query (Consulta).


b. En Partition key (Clave de partición), especifique el valor Amazon DynamoDB#DynamoDB
Thread 1.
c. Elija Inicio. Solo se devolverán los elementos de la tabla Reply que coincidan con los criterios de
la consulta.
7. LaReplytiene un índice secundario global en laPostedByyMessageAtributos. Puede usar el panel de
filtrado de datos para consultar el índice. Haga lo siguiente:

a. Cambie el origen de la consulta a partir de lo siguiente:

Versión de API 2012-08-10


337
Amazon DynamoDB Guía para desarrolladores
Ejemplos de código Java

[Table] Reply: Id, ReplyDateTime

A lo siguiente:

[Index] PostedBy-Message-Index: PostedBy, Message


b. En Partition key (Clave de partición), especifique el valor User A.
c. Elija Inicio. Solo se devolverán los elementos de PostedBy-Message-Index que coincidan con
los criterios de la consulta.

Dedique un tiempo a explorar las otras tablas en la consola de DynamoDB:

• ProductCatalog
• Forum
• Thread

Paso 4: (Opcional) Limpieza


Estas tablas de ejemplo se utilizan en toda laGuía para desarrolladores de Amazon DynamoDBPara
ayudar a ilustrar las operaciones con tablas y elementos realizadas mediante el API de bajo nivel de y los
distintosAWSSDK. Si tiene previsto leer el resto de esta guía. estas tablas pueden resultarle útiles para
consultarlas. No obstante, si no desea conservarlas, debe eliminarlas para evitar que se le cobre por los
recursos que no necesita.

Para eliminar los ejemplos de tablas

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.


2. En el panel de navegación, elija Tables (Tablas).
3. En la lista de tablas, elija ProductCatalog.
4. Elija Delete Table (Eliminar tabla). Se le pide que confirme la selección.

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.

Ejemplos de código Java


Temas
• Java: Configuración deAWSCredenciales (p. 340)

Versión de API 2012-08-10


338
Amazon DynamoDB Guía para desarrolladores
Ejemplos de código Java

• Java: Configuración deAWSRegión y punto de enlace (p. 340)

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:

• Uso de elementos y atributos (p. 410)


• Uso de tablas y datos en DynamoDB (p. 344)
• Uso de consultas en DynamoDB (p. 497)
• Uso de operaciones de examen en DynamoDB (p. 516)
• Uso de índices secundarios para mejorar el acceso a los datos (p. 567)
• Java: DynamoDBMapper (p. 231)
• Captura de datos de cambio para DynamoDB Streams (p. 661)

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.

Para ejecutar los ejemplos de código Java (con Eclipse)

1. Descargue e instale el IDE de Eclipse.


2. Descargue e instale el AWS Toolkit for Eclipse.
3. Inicie Eclipse y, en el menú Eclipse, elija File (Archivo), New (Nuevo) y después Other (Otro).
4. EnSeleccione un asistente, elijaAWS, elijaAWSProyecto Javay luego seleccioneSiguiente.
5. EnCreación de unAWSJava, realice una de las siguientes opciones:

a. En Project name (Nombre del proyecto), introduzca un nombre para el proyecto.


b. En Select Account (Seleccionar cuenta), elija su perfil de credenciales en la lista.

Si es la primera vez que utiliza elAWS Toolkit for Eclipse, elijaConfiguraciónAWSCuentasPara


configurar suAWSCredenciales de .
6. Elija Finish (Finalizar) para crear el proyecto.
7. En el menú Eclipse, elija File (Archivo), New (Nuevo) y después Class (Clase).
8. En Java Class (Clase Java), introduzca un nombre para la clase en Name (Nombre) (use el mismo
nombre que en el ejemplo de código que desea ejecutar) y, a continuación, elija Finish (Finalizar) para
crear la clase.
9. Copie el ejemplo de código de la página de documentación en el editor de Eclipse.
10. Para ejecutar el código, elija Run (Ejecutar) en el menú Eclipse.

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.

Para obtener más información, consulte la AWS SDK for Java.


Note

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.

Versión de API 2012-08-10


339
Amazon DynamoDB Guía para desarrolladores
Ejemplos de código .NET

Java: Configuración deAWSCredenciales


El SDK for Java requiere que proporcioneAWSen tiempo de ejecución. En los ejemplos de código de esta
guía se presupone que utiliza unAWS, como se describe enConfiguración deAWSCredencialesen laAWS
SDK for JavaGuía para desarrolladores.

A continuación se muestra un ejemplo deAWSarchivo de credenciales denominado~/.aws/


credentials, donde el carácter tilde (~) representa el directorio de inicio.

[default]
aws_access_key_id = AWS access key ID goes here
aws_secret_access_key = Secret key goes here

Java: Configuración deAWSRegión y punto de enlace


De forma predeterminada, los ejemplos de código acceden a DynamoDB en la región EE. UU. Oeste
(Oregón). Puede cambiar la región modificando las propiedades de AmazonDynamoDB.

En el siguiente ejemplo de código se crea una nueva instancia de AmazonDynamoDB.

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

Puede utilizar la propiedadwithRegionPara ejecutar el código en DynamoDB en cualquier región donde


se encuentre disponible. Para ver una lista completa, 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.

AWSSDK V1

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().withEndpointConfiguration(


new AwsClientBuilder.EndpointConfiguration("http://localhost:8000", "us-west-2"))
.build();

AWSSDK V2

DynamoDbClient client = DynamoDbClient.builder()


.endpointOverride(URI.create("http://localhost:8000"))
// The region is meaningless for local DynamoDb but required for client builder
validation
.region(Region.US_EAST_1)
.credentialsProvider(StaticCredentialsProvider.create(
AwsBasicCredentials.create("dummy-key", "dummy-secret")))
.build();

Ejemplos de código .NET


Temas
• .NET: Configuración deAWSCredenciales (p. 342)

Versión de API 2012-08-10


340
Amazon DynamoDB Guía para desarrolladores
Ejemplos de código .NET

• .NET: Configuración deAWSRegión y punto de enlace (p. 342)

Esta guía contiene fragmentos de código .NET y programas listos para ejecutarlos. Encontrará estos
ejemplos de código en las secciones siguientes:

• Uso de elementos y atributos (p. 410)


• Uso de tablas y datos en DynamoDB (p. 344)
• Uso de consultas en DynamoDB (p. 497)
• Uso de operaciones de examen en DynamoDB (p. 516)
• Uso de índices secundarios para mejorar el acceso a los datos (p. 567)
• .NET: Modelo de documento (p. 279)
• .NET: Modelo de persistencia de objetos (p. 303)
• Captura de datos de cambio para DynamoDB Streams (p. 661)

Puede comenzar rápidamente a trabajar con elAWS SDK for .NETCon el Toolkit for Visual Studio.

Para ejecutar los ejemplos de código .NET (mediante Visual Studio)

1. Descargue e instale Microsoft Visual Studio.


2. Descargue e instaleToolkit for Visual Studio.
3. Inicie Visual Studio. Elija File (Archivo), New (Nuevo), Project (Proyecto).
4. EnNuevo proyecto, elijaAWSProyecto Emptyy luego seleccioneACEPTAR.
5. EnAWSCredenciales, elijaUsar perfil existenteEn, elija su perfil de credenciales en la lista y, a
continuación, haga clic enACEPTAR.

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.

Para obtener más información, consulte AWS SDK para .NET.


Note

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.

Versión de API 2012-08-10


341
Amazon DynamoDB Guía para desarrolladores
Ejemplos de código .NET

.NET: Configuración deAWSCredenciales


LaAWS SDK for .NETrequiere que proporcioneAWSen tiempo de ejecución. En los ejemplos de código
de esta guía se presupone que utiliza el SDK Store para administrar suAWS, como se describe enUso del
SDK Storeen laAWS SDK for .NETGuía para desarrolladores.

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.

En el siguiente ejemplo se muestra laApp.configque se genera al crear un nuevo proyecto utilizando


Toolkit for Visual Studio.

<?xml version="1.0" encoding="utf-8" ?>


<configuration>
<appSettings>
<add key="AWSProfileName" value="default"/>
<add key="AWSRegion" value="us-west-2" />
</appSettings>
</configuration>

En tiempo de ejecución, el programa utiliza el métododefaultconjunto deAWS, tal como se especifica


en la propiedadAWSProfileNameEntrada. LaAWSLas credenciales en sí se conservan en SDK Store
cifradas. El Toolkit for Visual Studio proporciona una interfaz gráfica de usuario para administrar las
credenciales, todo ello desde Visual Studio. Para obtener más información, consulteEspecificación de
credencialesen laAWS Toolkit for Visual StudioGuía del usuario.
Note

De forma predeterminada, los ejemplos de código acceden a DynamoDB en la región EE.


UU. Oeste (Oregón). Puede cambiar la región modificando la entrada AWSRegion en el
archivo App.config. Es posible establecerAWSRegionen cualquier región donde DynamoDB
esté disponible. Para ver una lista completa, consulteAWSRegiones y puntos de enlace deen
laReferencia general de Amazon Web Services.

.NET: Configuración deAWSRegión y punto de enlace


De forma predeterminada, los ejemplos de código acceden a DynamoDB en la región EE. UU. Oeste
(Oregón). Puede cambiar la región modificando la entrada AWSRegion en el archivo App.config. O bien
puede cambiar la región modificando las propiedades de AmazonDynamoDBClient.

En el siguiente ejemplo de código se crea una nueva instancia de AmazonDynamoDBClient. El cliente se


modifica de tal forma que el código se ejecute en DynamoDB en otra región.

AmazonDynamoDBConfig clientConfig = new AmazonDynamoDBConfig();


// This client will access the US East 1 region.
clientConfig.RegionEndpoint = RegionEndpoint.USEast1;
AmazonDynamoDBClient client = new AmazonDynamoDBClient(clientConfig);

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.

AmazonDynamoDBConfig clientConfig = new AmazonDynamoDBConfig();


// Set the endpoint URL
clientConfig.ServiceURL = "http://localhost:8000";

Versión de API 2012-08-10


342
Amazon DynamoDB Guía para desarrolladores
Ejemplos de código .NET

AmazonDynamoDBClient client = new AmazonDynamoDBClient(clientConfig);

Versión de API 2012-08-10


343
Amazon DynamoDB Guía para desarrolladores
Uso de tablas

Uso de tablas, elementos, consultas,


análisis e índices
En esta sección se proporciona detalles sobre el uso de tablas, elementos, consultas y mucho más en
Amazon DynamoDB.

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)

Uso de tablas y datos en DynamoDB


En esta sección se describe cómo utilizar la funciónAWS Command Line Interface(AWS CLI) y elAWSSDK
para crear, actualizar y eliminar tablas en Amazon DynamoDB.
Note

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)

Operaciones básicas en tablas de DynamoDB


Al igual que otros sistemas de bases de datos, Amazon DynamoDB almacena datos en tablas. Puede
administrar las tablas con una pocas operaciones básicas.

Versión de API 2012-08-10


344
Amazon DynamoDB Guía para desarrolladores
Operaciones básicas en tablas de

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)

Creación de una tabla


UsarCreateTablepara crear una tabla en Amazon DynamoDB. Para crear la tabla, debe proporcionar la
siguiente información:

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

Ejemplo 1: Creación de una tabla aprovisionada


En el ejemplo siguiente de la AWS CLI se muestra cómo crear una tabla (Music). La clave principal
consta de Artist (clave de partición) y SongTitle (clave de ordenación), ambas de tipo String. El
desempeño máximo de esta tabla es de 10 unidades de capacidad de lectura y 5 unidades de capacidad
de escritura.

aws dynamodb create-table \


--table-name Music \
--attribute-definitions \
AttributeName=Artist,AttributeType=S \
AttributeName=SongTitle,AttributeType=S \
--key-schema \
AttributeName=Artist,KeyType=HASH \
AttributeName=SongTitle,KeyType=RANGE \
--provisioned-throughput \
ReadCapacityUnits=10,WriteCapacityUnits=5

La operación CreateTable devuelve metadatos de la tabla, como se muestra a continuación:

{
"TableDescription": {
"TableArn": "arn:aws:dynamodb:us-east-1:123456789012:table/Music",
"AttributeDefinitions": [
{
"AttributeName": "Artist",

Versión de API 2012-08-10


345
Amazon DynamoDB Guía para desarrolladores
Operaciones básicas en tablas de

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

Ejemplo 2: Creación de una tabla bajo demanda


Para crear la misma tabla Music utilizando el modo bajo demanda:

aws dynamodb create-table \


--table-name Music \
--attribute-definitions \
AttributeName=Artist,AttributeType=S \
AttributeName=SongTitle,AttributeType=S \
--key-schema \
AttributeName=Artist,KeyType=HASH \
AttributeName=SongTitle,KeyType=RANGE \
--billing-mode=PAY_PER_REQUEST

La operación CreateTable devuelve metadatos de la tabla, como se muestra a continuación:

{
"TableDescription": {
"TableArn": "arn:aws:dynamodb:us-east-1:123456789012:table/Music",
"AttributeDefinitions": [
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "SongTitle",
"AttributeType": "S"
}

Versión de API 2012-08-10


346
Amazon DynamoDB Guía para desarrolladores
Operaciones básicas en tablas de

],
"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.

Descripción de una tabla


Para ver información detallada sobre una tabla, utilice la operación DescribeTable. Debe proporcionar
el nombre de la tabla. El resultado de DescribeTable tiene el mismo formato que el de CreateTable;
Incluye la marca temporal del momento de creación de la tabla, su esquema de claves, sus ajustes de
desempeño provisionado, su tamaño aproximado y los índices secundarios que contiene.
Important

Al llamar a DescribeTable en una tabla bajo demanda, las unidades de capacidad de lectura y
de escritura se establecen en 0.

Example

aws dynamodb describe-table --table-name Music

La tabla está lista para usarla cuando el valor de TableStatus cambia de CREATING a ACTIVE.
Note

Si emite unDescribeTableinmediatamente después de unaCreateTable, DynamoDB puede


devolver un error (ResourceNotFoundException). El motivo es que DescribeTable usa una
consulta con consistencia final, aunque los metadatos de la tabla podrían no estar disponibles
todavía. Espere unos segundos y repita la solicitud DescribeTable.
A efectos de facturación, los costos de almacenamiento de DynamoDB incluyen un importe
por elemento de 100 bytes en concepto de gastos generales. (Para obtener más información,
consultePrecios de DynamoDB.) Este importe adicional de 100 bytes por elemento no se utiliza al
calcular las unidades de capacidad ni en la funciónDescribeTable.

Versión de API 2012-08-10


347
Amazon DynamoDB Guía para desarrolladores
Operaciones básicas en tablas de

Actualización de una tabla


La operación UpdateTable permite realizar una de las acciones siguientes:

• 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:

aws dynamodb update-table --table-name Music \


--provisioned-throughput ReadCapacityUnits=20,WriteCapacityUnits=10

Note

Cuando se emite una solicitud UpdateTable, el estado de la tabla cambia de AVAILABLE a


UPDATING. La tabla permanece plenamente disponible para su uso mientras se encuentra en el
estado UPDATING. Cuando este proceso finaliza, el estado de la tabla cambia de UPDATING a
AVAILABLE.

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:

aws dynamodb update-table --table-name Music \


--billing-mode PAY_PER_REQUEST

Eliminación de una tabla


Puede eliminar las tablas que no utilice con la operación DeleteTable. La eliminación de una tabla es
una operación irrecuperable.

Example
En el ejemplo siguiente de AWS CLI, se muestra cómo se elimina una tabla.

aws dynamodb delete-table --table-name Music

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.

Cuando laDeleteTable, la tabla ya no existirá en DynamoDB.

Enumeración de nombres de tablas


LaListTablesLa operación devuelve los nombres de las tablas de DynamoDB delAWSCuenta y región.

Versión de API 2012-08-10


348
Amazon DynamoDB Guía para desarrolladores
Consideraciones sobre el cambio del
modo de capacidad de lectura/escritura

Example
Los siguientes ejemplos deAWS CLImuestra cómo enumerar los nombres de las tablas de DynamoDB.

aws dynamodb list-tables

Descripción de las cuotas de rendimiento aprovisionado


LaDescribeLimitsLa operación devuelve las cuotas vigentes de capacidad de lectura y escritura de
laAWSCuenta y región.

Example
En el siguiente ejemplo de la AWS CLI se muestra cómo describir las cuotas de rendimiento aprovisionado
actuales.

aws dynamodb describe-limits

El resultado muestra las cuotas superiores de unidades de capacidad de lectura y escritura de


laAWSCuenta y región.

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

Consideraciones sobre el cambio del modo de


capacidad de lectura/escritura
Puede cambiar entre los modos de capacidad de lectura/escritura una vez cada 24 horas. Tenga en cuenta
lo siguiente al actualizar el modo de capacidad de lectura/escritura en Amazon DynamoDB.

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.

Administración de Auto Scaling


Al actualizar una tabla del modo aprovisionado al modo bajo demanda:

Versión de API 2012-08-10


349
Amazon DynamoDB Guía para desarrolladores
Tablas de capacidad aprovisionadas

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

Al actualizar una tabla del modo bajo demanda al modo aprovisionado:

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

Administración de la configuración en tablas de


capacidad provisionadas de DynamoDB
Al crear una nueva tabla aprovisionada en Amazon DynamoDB, debe especificar suCapacidad
aprovisionada. Esta es la cantidad de actividad de lectura y escritura que la tabla puede admitir.
DynamoDB utiliza esta información para reservar recursos del sistema suficientes para satisfacer sus
necesidades de desempeño.
Note

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.

Especifique los requisitos de rendimiento en términos deunidades de capacidad: la cantidad de datos


que la aplicación tiene que leer o escribir por segundo. Puede cambiar estos ajustes más adelante, si es
necesario, o habilitar la función Auto Scaling de DynamoDB para que se modifiquen automáticamente.

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)

Versión de API 2012-08-10


350
Amazon DynamoDB Guía para desarrolladores
Tablas de capacidad aprovisionadas

• Limitación controlada de solicitudes y capacidad de adaptación (p. 353)


• Elección de los ajustes de desempeño iniciales (p. 353)
• Modificación de los ajustes de desempeño (p. 354)

Unidades de capacidad de lectura


AUnidad 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.
Note

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.

Consumo de unidades de capacidad para las lecturas


A continuación se describe cómo se consumen las unidades de capacidad de lectura en las operaciones
de lectura de DynamoDB

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

Versión de API 2012-08-10


351
Amazon DynamoDB Guía para desarrolladores
Tablas de capacidad aprovisionadas

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.

Operaciones de lectura y consistencia de lectura


En los cálculos anteriores se ha dado por hecho que las solicitudes son de lectura de consistencia alta.
Para las solicitudes de lectura consistente final, la operación consume solo la mitad de las unidades de
capacidad. Para una lectura consistente final, si el tamaño total de los elementos es de 80 KB, la operación
consume solo 10 unidades de capacidad.

Unidades de capacidad de escritura


Aunidad de capacidad de escriturarepresenta una escritura por segundo para un elemento con un tamaño
de hasta 1 KB.

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.

Consumo de unidades de capacidad para las escrituras


A continuación se describe cómo se consumen las unidades de capacidad de escritura en las operaciones
de escritura de DynamoDB

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

ParaPutItem,UpdateItem, yDeleteItem, DynamoDB redondea el tamaño del elemento al siguiente 1


KB. Por ejemplo, si coloca o elimina un elemento de 1,6 KB, DynamoDB redondeará su tamaño a 2 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

Versión de API 2012-08-10


352
Amazon DynamoDB Guía para desarrolladores
Tablas de capacidad aprovisionadas

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.

Limitación controlada de solicitudes y capacidad de ráfaga


Si la aplicación lleva a cabo lecturas o escrituras a una velocidad mayor que la admitida por la tabla,
DynamoDB comienza aaceleradoresas solicitudes. Cuando DynamoDB limita una lectura o escritura,
devuelve unProvisionedThroughputExceededExceptionA la persona que llama. A continuación,
la aplicación puede adoptar las medidas pertinentes, como esperar un breve intervalo de tiempo antes de
repetir la solicitud.
Note

Le recomendamos que utilice laAWSSDK para el desarrollo de software. LaAWSLos SDK


incluyen compatibilidad integrada para reintentar las solicitudes que han sido objeto de una
limitación controlada; no tendrá que escribir personalmente esta lógica. Para obtener más
información, consulte Reintentos de error y retardo exponencial (p. 229).

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

Limitación controlada de solicitudes y capacidad de adaptación


DynamoDB distribuye automáticamente los datos entre las particiones, que se almacenan en varios
servidores de laAWSPara obtener más información, consultePartitions y distribución de datos (p. 23)).
No siempre es posible distribuir uniformemente la actividad de lectura y escritura. Si el acceso a los
datos está desequilibrado, una partición "caliente" podría recibir un volumen mayor de tráfico de lectura y
escritura que otras particiones. De forma automática, la capacidad de adaptación hace que la capacidad de
rendimiento aumente en las particiones que reciben más tráfico. Para obtener más información, consulte
Descripción de la capacidad de adaptación de DynamoDB (p. 997).

Elección de los ajustes de desempeño iniciales


Cada aplicación tiene requisitos diferentes de lectura y escritura en la base de datos. Al determinar los
ajustes de desempeño iniciales de una tabla de DynamoDB, debe tener en cuenta los siguientes datos:

• 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

Versión de API 2012-08-10


353
Amazon DynamoDB Guía para desarrolladores
Tamaños y formatos de elementos

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:

• 3 KB/4 KB = 0,75, o1Unidad de capacidad de lectura

En este caso, deberá establecer el nivel de desempeño provisionado de la tabla en 80 unidades de


capacidad de lectura:

• 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:

• 512 bytes/1 KB = 0,5, o1

En este caso, es conveniente establecer el nivel de desempeño de escritura provisionado de la tabla en


100 unidades de capacidad de escritura:

• 1 unidad de capacidad de escritura por elemento × 100 escrituras por segundo = 100 unidades de


capacidad de escritura

Note

Para obtener recomendaciones sobre el desempeño provisionado y temas relacionados, consulte


Prácticas recomendadas para diseñar y utilizar claves de partición de forma eficaz (p. 996).

Modificación de los ajustes de desempeño


Si ha habilitado la función Auto Scaling de DynamoDB en una tabla, la capacidad de desempeño de esta
se ajustará dinámicamente en respuesta al uso que se haga de ella. No se requiere intervención manual
alguna.

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

Tamaños y formatos de elementos de DynamoDB


Las tablas de DynamoDB no tienen esquemas, salvo la clave principal. Por este motivo, todos los
elementos de una tabla pueden tener atributos, tamaños y tipos de datos distintos.

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:

Versión de API 2012-08-10


354
Amazon DynamoDB Guía para desarrolladores
Administración de la capacidad
de desempeño con Auto Scaling

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

Administración automática de la capacidad de


desempeño con la función Auto Scaling de DynamoDB
Muchas cargas de trabajo de base de datos son cíclicas o difíciles de predecir con antelación. Por ejemplo,
tomemos una aplicación de redes sociales en la que la mayoría de los usuarios están activos en el horario
diurno. La base de datos debe satisfacer los requisitos de la actividad diurna, pero no se requieren los
mismos niveles de desempeño por la noche. Otro ejemplo podría ser una nueva aplicación de juegos
para móviles cuya adopción está siendo muy rápida. Si el juego adquiere demasiada popularidad, podría
superar los recursos disponibles en la base de datos, lo que daría lugar a un desempeño lento y a clientes
descontentos. Estos tipos de cargas de trabajo suelen requerir intervención manual para escalar los
recursos de la base de datos en sentido ascendente o descendente en respuesta a las variaciones en los
niveles de uso.

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.

La directiva de escalado también contiene unUso objetivo: porcentaje de desempeño provisionado


consumido en un momento dado. Application Auto ScalingSeguimiento de destino .Algoritmo de ajustar
el desempeño provisionado de la tabla o el índice al alza o a la baja en respuesta a las cargas de trabajo
reales, de tal forma que la utilización de la capacidad real se mantenga en valores iguales o parecidos al
objetivo de utilización.

Versión de API 2012-08-10


355
Amazon DynamoDB Guía para desarrolladores
Administración de la capacidad
de desempeño con Auto Scaling

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.

Funcionamiento del Auto Scaling DynamoDB


Note

Para comenzar rápidamente a usar la función Auto Scaling de DynamoDB, consulteMediante


laAWS Management ConsoleAuto Scaling de DynamoDB (p. 358).

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:

1. Cree una directiva de Application Auto Scaling para la tabla de DynamoDB.


2. DynamoDB publica métricas de capacidad consumida en Amazon CloudWatch.
3. Si la capacidad consumida de la tabla supera el objetivo de utilización (o no lo alcanza) durante un
periodo de tiempo específico, Amazon CloudWatch activa una alarma. Puede ver la alarma en la
consola y recibir notificaciones mediante Amazon Simple Notification Service (Amazon SNS).
4. La alarma de CloudWatch invoca Application Auto Scaling para evaluar la política de escalado.

Versión de API 2012-08-10


356
Amazon DynamoDB Guía para desarrolladores
Administración de la capacidad
de desempeño con Auto Scaling

5. Application Auto ScalingUpdateTablePara ajustar el desempeño provisionado de la tabla.


6. DynamoDB procesa laUpdateTable, aumentando (o disminuyendo) dinámicamente la capacidad de
desempeño provisionada de la tabla para que sea parecida al objetivo de utilización.

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:

• La tabla o el índice secundario global que desea administrar


• Qué tipo de capacidad va a administrar (capacidad de lectura o capacidad de escritura)
• Los límites superior e inferior de los ajustes de desempeño provisionado
• Su objetivo de utilización

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:

• La función Auto Scaling de DynamoDB de puede aumentar la capacidad de lectura o escritura


tan a menudo como sea preciso, de acuerdo con la política de Auto Scaling. Todas las cuotas de
DynamoDB permanecen en vigor, tal como se describe enCuotas de servicio, cuenta y tabla en Amazon
DynamoDB (p. 1066).

Versión de API 2012-08-10


357
Amazon DynamoDB Guía para desarrolladores
Administración de la capacidad
de desempeño con Auto Scaling

• El escalado automático de DynamoDB no le impide modificar manualmente los ajustes de desempeño


provisionado. Estos ajustes manuales no afectan a las alarmas de CloudWatch vigentes relacionadas
con la función Auto Scaling de DynamoDB.
• Si habilita Auto Scaling de DynamoDB para una tabla que tiene uno o varios índices secundarios
globales, recomendamos encarecidamente aplicar también Auto Scaling de manera uniforme a
esos índices. Para ello, elijaAplicar la misma configuración a índices secundarios globalesen laAWS
Management Console. Para obtener más información, consulte Habilitación del Auto Scaling DynamoDB
en tablas existentes (p. 359).

Mediante laAWS Management ConsoleAuto Scaling de


DynamoDB
Cuando se utiliza elAWS Management ConsolePara crear una tabla nueva, la función Auto Scaling
de Amazon DynamoDB se habilita para esa tabla de forma predeterminada. También puede utilizar la
consola para habilitar Auto Scaling en las tablas existentes, modificar la configuración de esta función o
deshabilitarla.
Note

Para obtener funciones más avanzadas como la configuración de plazos de recuperación de


escalado ascendente y descendente, utilice laAWS Command Line Interface(AWS CLI) para
administrar el escalado automático de DynamoDB. Para obtener más información, consulte
Mediante laAWS CLIpara administrar el Auto Scaling de DynamoDB (p. 360).

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)

Antes de comenzar: Concesión de permisos de usuario para DynamoDB Auto


Scaling
EnAWS Identity and Access Management(IAM), la política administrada de
AWSDynamoDBFullAccessproporciona los permisos necesarios para usar la consola de DynamoDB.
Sin embargo, para el escalado automático de DynamoDB, los usuarios de IAM requieren privilegios
adicionales.
Important

application-autoscaling:*Los permisos son necesarios para eliminar una tabla habilitada


con escalado automático. La política administrada de AWSDynamoDBFullAccessincluye dichos
permisos.

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 adjuntar la política AmazonDynamoDBFullAccess

1. Inicie sesión en la AWS Management Console y abra la consola de IAM en https://


console.aws.amazon.com/iam/.
2. En el panel de la consola de IAM, elija.Usuarios dey, a continuación, seleccione el usuario de IAM en
la lista.

Versión de API 2012-08-10


358
Amazon DynamoDB Guía para desarrolladores
Administración de la capacidad
de desempeño con Auto Scaling

3. En la página Summary, elija Add permissions.


4. Elija Attach existing policies directly (Adjuntar políticas existentes directamente).
5. En la lista de políticas, elijaAmazonDynamoDBFullAccessHaga clic en y luego enSiguiente: Consulte.
6. Elija Add permissions.

Creación de una nueva tabla con la función Auto Scaling habilitada


Note

La función Auto Scaling de DynamoDB de requiere la presencia de un rol vinculado al servicio


(AWSServiceRoleForApplicationAutoScaling_DynamoDBTable) que lleva a cabo las
acciones de Auto Scaling en su nombre. Este rol se crea automáticamente. Para obtener más
información, consulte Roles vinculados a servicios de Auto Scaling de aplicaciones en la Guía del
usuario de Auto Scaling de aplicaciones.

Para crear una nueva tabla con la función Auto Scaling habilitada

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.


2. Seleccione Create Table (Crear tabla).
3. En la página Create DynamoDB table, especifique los detalles de Table name y Primary key.
4. Asegúrese de queUsar configuración predeterminadaestá seleccionada. (SusAWScuenta ya
tieneAWSServiceRoleForApplicationAutoScaling_DynamoDBTable.)

De lo contrario, para la configuración personalizada:

1. ClearUsar configuración predeterminada.


2. En el navegadorAuto Scaling, establezca la configuración de parámetros y asegúrese de
queAWSServiceRoleForApplicationAutoScaling_DynamoDBTableestá seleccionada.
5. Cuando esté conforme con los ajustes, elija Create (Crear). La tabla se crea con los parámetros de
Auto Scaling.

Habilitación del Auto Scaling DynamoDB en tablas existentes


Note

La función Auto Scaling de DynamoDB de requiere la presencia de un rol vinculado al servicio


(AWSServiceRoleForApplicationAutoScaling_DynamoDBTable) que lleva a cabo las
acciones de Auto Scaling en su nombre. Este rol se crea automáticamente. Para obtener más
información, consulteRoles vinculados a servicios para Application Auto Scaling.
Si nunca había usado la función Auto Scaling de DynamoDB, consulteCreación de una nueva
tabla con la función Auto Scaling habilitada (p. 359).

Para habilitar la función Auto Scaling de DynamoDB en una tabla existente

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.


2. Elija la tabla que desee usar y, a continuación, elija Capacity.
3. En la sección Auto Scaling, haga lo siguiente:

• SelectCapacidad de lectura,Capacidad de escritura, o ambas. (Para la capacidad de escritura,


puede elegirMisma configuración que leer.) Para cada capacidad, configure lo siguiente:

• Objetivo de utilización: escriba el porcentaje de objetivo de utilización de la tabla.


• Capacidad aprovisionada mínima: escriba el límite inferior del rango de Auto Scaling.

Versión de API 2012-08-10


359
Amazon DynamoDB Guía para desarrolladores
Administración de la capacidad
de desempeño con Auto Scaling

• 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 obtener el máximo desempeño, le recomendamos habilitarAplicar la misma


configuración a índices secundarios globales. Esta opción permite que la función Auto
Scaling de DynamoDB aplique un escalado uniforme a todos los índices secundarios
globales de la tabla base. Esto incluye los índices secundarios globales existentes y
cualesquiera otros que se creen en esta tabla en el futuro.
Con esta opción habilitada, no se puede establecer una política de escalado para un
índice secundario global individual.

(ParaCapacidad de escritura, puede elegirMisma configuración que leer.)

En el navegadorIAM Role, asegúrese de


queAWSServiceRoleForApplicationAutoScaling_DynamoDBTableestá seleccionada.
4. Cuando la configuración sea la que desea, elija Save (Guardar).

Visualización de las actividades de Auto Scaling en la consola


A medida que la aplicación envía tráfico de lectura y escritura a la tabla, la función Auto Scaling de
DynamoDB modifica de forma dinámica los ajustes de desempeño de esa tabla.

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.

Modificación o deshabilitación de los ajustes de Auto Scaling de DynamoDB


Puede utilizar laAWS Management ConsolePara modificar los ajustes de Auto Scaling de DynamoDB.
Para ello, vaya a la página deCapacidadpara la tabla y modifique los ajustes de laAuto Scalingsección.
Para obtener más información sobre estas opciones, consulte Habilitación del Auto Scaling DynamoDB en
tablas existentes (p. 359).

Para deshabilitar el escalado automático de DynamoDB, vaya a la páginaCapacidadpara la tabla y


desactiveCapacidad de lectura,Capacidad de escritura, o ambas.

Mediante laAWS CLIpara administrar el Auto Scaling de


DynamoDB
En lugar de usar la funciónAWS Management ConsoleEn el caso de, puede utilizar laAWS Command
Line Interface(AWS CLI) para administrar el escalado automático de Amazon DynamoDB. En el tutorial de
esta sección se muestra cómo instalar y configurar laAWS CLIpara administrar el escalado automático de
DynamoDB. En este tutorial, aprenderá a hacer lo siguiente:

• 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

Versión de API 2012-08-10


360
Amazon DynamoDB Guía para desarrolladores
Administración de la capacidad
de desempeño con Auto Scaling

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.

Instalación del AWS CLI

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 la AWS CLI


• Configuración d AWS CLI

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.

Paso 1: Creación de una tabla de DynamoDB


En este paso, utilice laAWS CLIPara crearTestTable. La clave principal consiste enpk(clave de partición)
ysk(clave de ordenación). Ambos atributos son de tipo Number. Los ajustes de desempeño iniciales son
5 unidades de capacidad de lectura y 5 unidades de capacidad de escritura.

1. Utilice el siguienteAWS CLIPara crear la tabla.

aws dynamodb create-table \


--table-name TestTable \
--attribute-definitions \
AttributeName=pk,AttributeType=N \
AttributeName=sk,AttributeType=N \
--key-schema \
AttributeName=pk,KeyType=HASH \
AttributeName=sk,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5

2. Para comprobar el estado de la tabla, use el siguiente comando.

aws dynamodb describe-table \


--table-name TestTable \

Versión de API 2012-08-10


361
Amazon DynamoDB Guía para desarrolladores
Administración de la capacidad
de desempeño con Auto Scaling

--query "Table.[TableName,TableStatus,ProvisionedThroughput]"

La tabla está lista para usarla cuando su estado es ACTIVE.

Paso 2: Registrar un destino escalable


A continuación, registra la capacidad de escritura de la tabla como objetivo escalable en Application
Auto Scaling. Esto permite que Application Auto Scaling de ajuste la capacidad de escritura provisionada
paraTestTable, pero solo dentro del rango de entre 5 y 10 unidades de capacidad.
Note

La función Auto Scaling de DynamoDB de requiere la presencia de un rol vinculado al servicio


(AWSServiceRoleForApplicationAutoScaling_DynamoDBTable) que lleva a cabo las
acciones de Auto Scaling en su nombre. Este rol se crea automáticamente. Para obtener más
información, consulte Roles vinculados a servicios de Auto Scaling de aplicaciones en la Guía del
usuario de Auto Scaling de aplicaciones.

1. Para registrar el destino escalable, escriba el siguiente comando.

aws application-autoscaling register-scalable-target \


--service-namespace dynamodb \
--resource-id "table/TestTable" \
--scalable-dimension "dynamodb:table:WriteCapacityUnits" \
--min-capacity 5 \
--max-capacity 10

2. Para verificar el registro, use el siguiente comando.

aws application-autoscaling describe-scalable-targets \


--service-namespace dynamodb \
--resource-id "table/TestTable"

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.

aws application-autoscaling register-scalable-target \


--service-namespace dynamodb \
--resource-id "table/TestTable/index/test-index" \
--scalable-dimension "dynamodb:index:WriteCapacityUnits" \
--min-capacity 5 \
--max-capacity 10

Paso 3: Creación de una política de escalado


En este paso, se crea una política de escalado paraTestTable. La política define los detalles según los
cuales Application Auto Scaling puede ajustar el desempeño provisionado de la tabla y las acciones llevará
a cabo para ello. Puede asociar esta política al objetivo escalable definido en el paso anterior (unidades de
capacidad de escritura para elTestTableTabla).

La política contiene los componentes siguientes:

• PredefinedMetricSpecificationLa métrica que la función Auto Scaling de la aplicación puede


ajustar. Para DynamoDB, los siguientes valores son válidos paraPredefinedMetricType:

Versión de API 2012-08-10


362
Amazon DynamoDB Guía para desarrolladores
Administración de la capacidad
de desempeño con Auto Scaling

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

ParaTestTable, configuraTargetValue50 por cien. La Application Auto Scaling ajusta el


desempeño provisionado de la tabla dentro del rango comprendido entre 5 y 10 unidades de capacidad
(consultePaso 2: Registrar un destino escalable (p. 362)), de tal forma que la proporción entre
capacidad consumida y provisionada se mantiene en el 50% o en un valor próximo a este. Los valores de
ScaleOutCooldown y ScaleInCooldown se establecen en 60 segundos.

1. Cree un archivo denominado scaling-policy.json con el siguiente contenido.

{
"PredefinedMetricSpecification": {
"PredefinedMetricType": "DynamoDBWriteCapacityUtilization"
},
"ScaleOutCooldown": 60,
"ScaleInCooldown": 60,
"TargetValue": 50.0
}

2. Utilice el siguienteAWS CLIPara crear la política.

aws application-autoscaling put-scaling-policy \


--service-namespace dynamodb \
--resource-id "table/TestTable" \
--scalable-dimension "dynamodb:table:WriteCapacityUnits" \
--policy-name "MyScalingPolicy" \
--policy-type "TargetTrackingScaling" \
--target-tracking-scaling-policy-configuration file://scaling-policy.json

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.

Versión de API 2012-08-10


363
Amazon DynamoDB Guía para desarrolladores
Administración de la capacidad
de desempeño con Auto Scaling

aws application-autoscaling describe-scaling-policies \


--service-namespace dynamodb \
--resource-id "table/TestTable" \
--policy-name "MyScalingPolicy"

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

Paso 4: Tráfico de escritura de unidades en TestTable


Ahora puede probar la política de escalado escribiendo datos enTestTable. Para ello, se ejecuta un
programa de Python.

1. Cree un archivo denominado bulk-load-test-table.py con el siguiente contenido.

import boto3
dynamodb = boto3.resource('dynamodb')

table = dynamodb.Table("TestTable")

filler = "x" * 100000

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

2. Escriba el comando siguiente para ejecutar el programa.

python bulk-load-test-table.py

La capacidad de escritura provisionada paraTestTablees muy baja (5 unidades de capacidad de


escritura), por lo que el programa se detenga en ocasiones a causa de la limitación controlada de
escritura. Este es el comportamiento esperado.

Permita que el programa continúe ejecutándose mientras avanza al paso siguiente.

Paso 5: Acciones Application Auto Scaling


En este paso, consultaremos las acciones de Application Auto Scaling que se han iniciado en su nombre.
Asimismo, comprobaremos que Application Auto Scaling ha actualizado la capacidad de escritura
provisionada paraTestTable.

1. Escriba el comando siguiente para ver las acciones Application Auto Scaling.

aws application-autoscaling describe-scaling-activities \

Versión de API 2012-08-10


364
Amazon DynamoDB Guía para desarrolladores
Administración de la capacidad
de desempeño con 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"
},
...

Esto indica que Application Auto Scaling ha emitido unUpdateTableSolicite a DynamoDB.


2. Introduzca el siguiente comando para comprobar que DynamoDB ha aumentado la capacidad de
escritura de la tabla.

aws dynamodb describe-table \


--table-name TestTable \
--query "Table.[TableName,TableStatus,ProvisionedThroughput]"

WriteCapacityUnits debería haberse escalado de 5 a 10.

(Opcional) Paso 6: Eliminación


En este tutorial, ha creado varios recursos. Puede eliminar estos recursos cuando ya los necesite.

1. Elimine la política de escaladoTestTable.

aws application-autoscaling delete-scaling-policy \


--service-namespace dynamodb \
--resource-id "table/TestTable" \
--scalable-dimension "dynamodb:table:WriteCapacityUnits" \
--policy-name "MyScalingPolicy"

2. Anule el registro del objetivo escalable.

aws application-autoscaling deregister-scalable-target \


--service-namespace dynamodb \
--resource-id "table/TestTable" \
--scalable-dimension "dynamodb:table:WriteCapacityUnits"

3. Elimine la tabla TestTable.

aws dynamodb delete-table --table-name TestTable

Versión de API 2012-08-10


365
Amazon DynamoDB Guía para desarrolladores
Administración de la capacidad
de desempeño con Auto Scaling

Mediante laAWSSDK para configurar Auto Scaling en tablas de


Amazon DynamoDB
Además de usar elAWS Management Consoley laAWS Command Line Interface(AWS CLI), puede escribir
aplicaciones que interaccionen con el escalado automático de Amazon DynamoDB. Esta sección contiene
dos programas de Java que puede utilizar para probar esta funcionalidad:

• EnableDynamoDBAutoscaling.java
• DisableDynamoDBAutoscaling.java

Habilitación del Application Auto Scaling para una tabla


En el siguiente programa se muestra un ejemplo de cómo configurar una política de escalado automático
para una tabla de DynamoDB (TestTable). Funciona de la siguiente manera:

• 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;

Versión de API 2012-08-10


366
Amazon DynamoDB Guía para desarrolladores
Administración de la capacidad
de desempeño con Auto Scaling

import
com.amazonaws.services.applicationautoscaling.model.TargetTrackingScalingPolicyConfiguration;

public class EnableDynamoDBAutoscaling {

static AWSApplicationAutoScalingClient aaClient = (AWSApplicationAutoScalingClient)


AWSApplicationAutoScalingClientBuilder.standard().build();

public static void main(String args[]) {

ServiceNamespace ns = ServiceNamespace.Dynamodb;
ScalableDimension tableWCUs = ScalableDimension.DynamodbTableWriteCapacityUnits;
String resourceID = "table/TestTable";

// Define the scalable target


RegisterScalableTargetRequest rstRequest = new RegisterScalableTargetRequest()
.withServiceNamespace(ns)
.withResourceId(resourceID)
.withScalableDimension(tableWCUs)
.withMinCapacity(5)
.withMaxCapacity(10)
.withRoleARN("SERVICE_ROLE_ARN_GOES_HERE");

try {
aaClient.registerScalableTarget(rstRequest);
} catch (Exception e) {
System.err.println("Unable to register scalable target: ");
System.err.println(e.getMessage());
}

// Verify that the target was created


DescribeScalableTargetsRequest dscRequest = new DescribeScalableTargetsRequest()
.withServiceNamespace(ns)
.withScalableDimension(tableWCUs)
.withResourceIds(resourceID);
try {
DescribeScalableTargetsResult dsaResult =
aaClient.describeScalableTargets(dscRequest);
System.out.println("DescribeScalableTargets result: ");
System.out.println(dsaResult);
System.out.println();
} catch (Exception e) {
System.err.println("Unable to describe scalable target: ");
System.err.println(e.getMessage());
}

System.out.println();

// Configure a scaling policy


TargetTrackingScalingPolicyConfiguration targetTrackingScalingPolicyConfiguration =
new TargetTrackingScalingPolicyConfiguration()
.withPredefinedMetricSpecification(
new PredefinedMetricSpecification()
.withPredefinedMetricType(MetricType. DynamoDBWriteCapacityUtilization))
.withTargetValue(50.0)
.withScaleInCooldown(60)
.withScaleOutCooldown(60);

// Create the scaling policy, based on your configuration


PutScalingPolicyRequest pspRequest = new PutScalingPolicyRequest()
.withServiceNamespace(ns)
.withScalableDimension(tableWCUs)
.withResourceId(resourceID)
.withPolicyName("MyScalingPolicy")
.withPolicyType(PolicyType.TargetTrackingScaling)
.withTargetTrackingScalingPolicyConfiguration(targetTrackingScalingPolicyConfiguration);

Versión de API 2012-08-10


367
Amazon DynamoDB Guía para desarrolladores
Administración de la capacidad
de desempeño con Auto Scaling

try {
aaClient.putScalingPolicy(pspRequest);
} catch (Exception e) {
System.err.println("Unable to put scaling policy: ");
System.err.println(e.getMessage());
}

// Verify that the scaling policy was created


DescribeScalingPoliciesRequest dspRequest = new DescribeScalingPoliciesRequest()
.withServiceNamespace(ns)
.withScalableDimension(tableWCUs)
.withResourceId(resourceID);

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

Deshabilitación del Application Auto Scaling para una tabla


En el siguiente programa se invierte el proceso anterior. Se elimina la política de escalado automático y, a
continuación, se anula el registro del objetivo escalable.

/**
* 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;

public class DisableDynamoDBAutoscaling {

static AWSApplicationAutoScalingClient aaClient = new


AWSApplicationAutoScalingClient();

Versión de API 2012-08-10


368
Amazon DynamoDB Guía para desarrolladores
Administración de la capacidad
de desempeño con Auto Scaling

public static void main(String args[]) {

ServiceNamespace ns = ServiceNamespace.Dynamodb;
ScalableDimension tableWCUs = ScalableDimension.DynamodbTableWriteCapacityUnits;
String resourceID = "table/TestTable";

// Delete the scaling policy


DeleteScalingPolicyRequest delSPRequest = new DeleteScalingPolicyRequest()
.withServiceNamespace(ns)
.withScalableDimension(tableWCUs)
.withResourceId(resourceID)
.withPolicyName("MyScalingPolicy");

try {
aaClient.deleteScalingPolicy(delSPRequest);
} catch (Exception e) {
System.err.println("Unable to delete scaling policy: ");
System.err.println(e.getMessage());
}

// Verify that the scaling policy was deleted


DescribeScalingPoliciesRequest descSPRequest = new DescribeScalingPoliciesRequest()
.withServiceNamespace(ns)
.withScalableDimension(tableWCUs)
.withResourceId(resourceID);

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

// Remove the scalable target


DeregisterScalableTargetRequest delSTRequest = new DeregisterScalableTargetRequest()
.withServiceNamespace(ns)
.withScalableDimension(tableWCUs)
.withResourceId(resourceID);

try {
aaClient.deregisterScalableTarget(delSTRequest);
} catch (Exception e) {
System.err.println("Unable to deregister scalable target: ");
System.err.println(e.getMessage());
}

// Verify that the scalable target was removed


DescribeScalableTargetsRequest dscRequest = new DescribeScalableTargetsRequest()
.withServiceNamespace(ns)
.withScalableDimension(tableWCUs)
.withResourceIds(resourceID);

try {
DescribeScalableTargetsResult dsaResult =
aaClient.describeScalableTargets(dscRequest);
System.out.println("DescribeScalableTargets result: ");
System.out.println(dsaResult);
System.out.println();
} catch (Exception e) {

Versión de API 2012-08-10


369
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

System.err.println("Unable to describe scalable target: ");


System.err.println(e.getMessage());
}

Tablas globales: Replicación en varias regiones con


DynamoDB

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

Versión de API 2012-08-10


370
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

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)

Determinación de la versión de las tablas globales utilizadas


Para saber qué versión de las tablas globales utiliza, haga lo siguiente:

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/home.


2. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas).
3. Elija la tabla que desea usar.
4. Elija la pestaña Global Tables (Tablas globales).

Versión de API 2012-08-10


371
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

5. Aparecerá Global table version (Versión de tabla global), que muestra la versión de las tablas globales
en uso.

Versión 2019.11.21 (actual)

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)

Tablas globales: Cómo funciona

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.

Conceptos de las tablas globales

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,

Versión de API 2012-08-10


372
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

DynamoDB propaga la operación de escritura en el resto de las tablas de réplica de la otraAWSRegiones


automáticamente.

Puede agregar tablas de réplica a la tabla global para que esté disponible en otras regiones.

Coherencia y resolución de conflictos

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.

Si las aplicaciones actualizan el mismo elemento en diferentes regiones aproximadamente al mismo


momento, pueden surgir conflictos. 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.

Prácticas recomendadas y requisitos para la administración de tablas globales

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.

Prácticas recomendadas y requisitos para administrar la capacidad

Tenga en cuenta lo siguiente al administrar la configuración de capacidad para tablas de réplica en


DynamoDB.

Versión de API 2012-08-10


373
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

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.

Para obtener más información sobre el escalado automático y DynamoDB, consulteAdministración


automática de la capacidad de desempeño con la función Auto Scaling de DynamoDB (p. 355).

Tutorial: Crear una tabla global

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)

Crear una tabla global (consola)

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.

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/home. Para realizar


este ejemplo, elija la región us-east-2 (EE. UU. Este [Ohio]).
2. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas).
3. SeleccionarCreación de tablas.

En Table name (Nombre de la tabla), introduzca Music.

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

Versión de API 2012-08-10


374
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

5. Elija Add region (Añadir región).

6. EnRegión, elijaEE.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.

SeleccionarCrear réplicasEsto inicia el proceso de creación de la tabla en EE.UU. Oeste (Oregó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

Versión de API 2012-08-10


375
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

elemento). ParaArtista, introduzcaitem_1. En SongTitle, escriba Song Value 1. Para escribir el


elemento, elijaSave (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.

Repita esto para EE. UU. Oeste (Oregón).

Creación de una tabla global (AWS CLI)

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

aws dynamodb create-table \


--table-name Music \
--attribute-definitions \
AttributeName=Artist,AttributeType=S \
AttributeName=SongTitle,AttributeType=S \
--key-schema \
AttributeName=Artist,KeyType=HASH \
AttributeName=SongTitle,KeyType=RANGE \
--billing-mode PAY_PER_REQUEST \
--stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES \
--region us-east-2

2. Creación de unMusicEn EE. UU. Este (Norte de Virginia).

aws dynamodb update-table --table-name Music --cli-input-json \


'{
"ReplicaUpdates":
[
{
"Create": {
"RegionName": "us-east-1"
}
}
]
}'

3. Repita el paso 2 para crear una tabla en Europa (Irlanda) (eu-west-1).


4. Puede ver la lista de réplicas creadas mediante describe-table.

aws dynamodb describe-table --table-name Music --region us-east-2

5. Para comprobar que la replicación funciona, añada un nuevo elemento alMusicEn EE. UU. Este
(Ohio).

aws dynamodb put-item \


--table-name Music \
--item '{"Artist": {"S":"item_1"},"SongTitle": {"S":"Song Value 1"}}' \
--region us-east-2

6. Espere unos segundos y, a continuación, compruebe si el elemento se replicó correctamente en los


Estados Unidos Este (Norte de Virginia) y Europa (Irlanda).
Versión de API 2012-08-10
376
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

aws dynamodb get-item \


--table-name Music \
--key '{"Artist": {"S":"item_1"},"SongTitle": {"S":"Song Value 1"}}' \
--region us-east-1

aws dynamodb get-item \


--table-name Music \
--key '{"Artist": {"S":"item_1"},"SongTitle": {"S":"Song Value 1"}}' \
--region eu-west-1

7. Elimine la tabla de réplica en la región Europa (Irlanda).

aws dynamodb update-table --table-name Music --cli-input-json \


'{
"ReplicaUpdates":
[
{
"Delete": {
"RegionName": "eu-west-1"
}
}
]
}'

Creación de una tabla global (Java)

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;

public class App


{
private final static Logger LOGGER = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);

Versión de API 2012-08-10


377
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

public static void main( String[] args )


{

String tableName = "Music";


String indexName = "index1";

Regions calledRegion = Regions.EU_WEST_1;


Regions destRegion = Regions.AP_NORTHEAST_2;

AmazonDynamoDB ddbClient = AmazonDynamoDBClientBuilder.standard()


.withCredentials(new ProfileCredentialsProvider("default"))
.withRegion(calledRegion)
.build();

LOGGER.info("Creating a regional table - TableName: " + tableName +", IndexName: "


+ indexName + " .....");
ddbClient.createTable(new CreateTableRequest()
.withTableName(tableName)
.withAttributeDefinitions(
new AttributeDefinition()

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

LOGGER.info("Waiting for ACTIVE table status .....");


ddbClient.waiters().tableExists().run(new WaiterParameters<>(new
DescribeTableRequest(tableName)));

LOGGER.info("Testing parameters for adding a new Replica in " + destRegion +


" .....");

CreateReplicationGroupMemberAction createReplicaAction = new


CreateReplicationGroupMemberAction()
.withRegionName(destRegion.getName())
.withGlobalSecondaryIndexes(new ReplicaGlobalSecondaryIndex()
.withIndexName(indexName)
.withProvisionedThroughputOverride(new
ProvisionedThroughputOverride()
.withReadCapacityUnits(15L)));

ddbClient.updateTable(new UpdateTableRequest()
.withTableName(tableName)
.withReplicaUpdates(new ReplicationGroupUpdate()
.withCreate(createReplicaAction.withKMSMasterKeyId(null))));

Versión de API 2012-08-10


378
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

}
}

Monitoreo de tablas globales

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.

• ReplicationLatency: el tiempo transcurrido entre el momento en que un elemento se escribe


en una tabla de réplica y el momento en que dicho elemento aparece en otra réplica de la tabla
global.ReplicationLatencyse expresa en milisegundos y se emite para cada uno de los pares de
región de origen y destino.

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

ReplicationLatencypuede aumentar si unAWSLa región se encuentra degradada y tiene una tabla


de réplica en esa región. En este caso, puede redirigir temporalmente la actividad de lectura y escritura
de la aplicación a otraAWSRegión .

Para obtener más información, consulte Dimensiones y métricas de DynamoDB (p. 940).

Usar IAM con tablas globales

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.

Versión de API 2012-08-10


379
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

• 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

Para actualizar la política de escalado automático de réplicas mediante


UpdateTableReplicaAutoScaling, debe tener los siguientes permisos en todas las regiones donde
haya tablas de réplica.

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

Ejemplo: Agregar 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",

Versión de API 2012-08-10


380
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

"Action": [
"dynamodb:CreateTable",
"dynamodb:DescribeTable",
"dynamodb:UpdateTable",
"dynamodb:CreateTableReplica",
"iam:CreateServiceLinkedRole"
],
"Resource": "*"
}
]
}

Ejemplo: Política de AutoScaling

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": "*"
}
]
}

Ejemplo: Permitir creaciones de réplicas para un nombre de tabla específico y determinadas


regiones

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"
]

Versión de API 2012-08-10


381
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

}
]
}

Actualización de tablas globales a la versión 2019.11.21 (actual)

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

Para actualizar a la versión 2019.11.21 (actual), debe tener permisos


dynamodb:UpdateGlobalTableVersion en las regiones de la réplica. Estos permisos se suman a los
permisos necesarios para acceder a la consola de DynamoDB y ver las tablas.

Versión de API 2012-08-10


382
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

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

Información general sobre el proceso de actualización

Durante el proceso de actualización, el estado de la tabla global cambia de ACTIVE a UPDATING.

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

• La actualización de la versión 2017.11.29 a la versión 2019.11.21 (actual) es una acción única


y no se puede revertir. Antes de proceder con la actualización, asegúrese de haber realizado
todas las pruebas necesarias. Espere 60 minutos antes de intentar actualizar una tabla global
recién creada.
• En la versión 2017.11.29 de las tablas globales, DynamoDB realizó una operación de escritura
para insertar tres atributos en el registro de elementos. Estos atributos (aws:rep:*) se
utilizaban para activar la replicación y administrar la resolución de conflictos. En la versión
2019.11.21 (actual) de las tablas globales, la actividad de replicación se administra de forma
nativa y no está expuesta a los usuarios.

Versión de API 2012-08-10


383
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

• La actualización a la versión 2019.11.21 (actual) solo está disponible a través de la consola de


DynamoDB.

Actualización a la versión 2019.11.21 (actual)

Siga estos pasos para actualizar la versión de las tablas globales de DynamoDB mediante laAWS
Management Console.

Para actualizar las tablas globales a la versión 2019.11.21

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/home.


2. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas), y, a continuación,
seleccione la tabla global que desea actualizar a la versión 2019.11.21 (actual).
3. Elija la pestaña Global Tables (Tablas globales).
4. Elija Update version (Actualizar versión).

5. Lea y acepte los nuevos requisitos y, a continuación, elija Continue (Continuar).


Important

La actualización de la versión 2017.11.29 a la versión 2019.11.21 (actual) es una acción


única y no se puede revertir. Antes de iniciar la actualización, asegúrese de haber realizado
todas las pruebas necesarias.

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 de API 2012-08-10


384
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

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)

Tablas globales: Cómo funciona

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.

Conceptos de las tablas globales

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:

Versión de API 2012-08-10


385
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

• aws:rep:deleting
• aws:rep:updatetime
• aws:rep:updateregion

No modifique estos atributos ni cree atributos con el mismo nombre.

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

Coherencia y resolución de conflictos

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.

Prácticas recomendadas y requisitos para la administración de tablas globales

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

Versión de API 2012-08-10


386
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

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)

Requisitos para agregar una tabla de réplica nueva

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:

• Los índices secundarios globales deben tener el mismo nombre.


• Los índices secundarios globales deben tener la misma clave de partición y clave de ordenación (si la
hay).

Important

La configuración de capacidad de escritura debe establecerse de forma coherente en todas


las tablas de réplicas globales y en los índices secundarios coincidentes. Para actualizar la
configuración de capacidad de escritura de la tabla global, recomendamos encarecidamente
utilizar la consola de DynamoDB o laUpdateGlobalTableSettingsOperación
API.UpdateGlobalTableSettingsaplica cambios a la configuración de capacidad de
escritura a todas las tablas de réplica y a los índices secundarios coincidentes de una tabla
global automáticamente. Si utiliza la opción deUpdateTable,RegisterScalableTarget,
o bienPutScalingPolicy, debe aplicar el cambio a cada tabla de réplicas y al
índice secundario coincidente individualmente. Para obtener más información,
consulteUpdateGlobalTableSettingsen laReferencia de la API de Amazon DynamoDB.
Se recomienda encarecidamente que habilite el escalado automático para administrar la
configuración de capacidad de escritura aprovisionada. Si prefiere administrar manualmente la
configuración de capacidad de escritura, debe aprovisionar unidades de capacidad de escritura
replicada iguales a todas las tablas de réplica. También aprovisione unidades de capacidad de
escritura replicada iguales para coincidencias de índices secundarios en toda la tabla global.
También debe tenerAWS Identity and Access Management(IAM). Para obtener más información,
consulte Usar IAM con tablas globales (p. 392).

Prácticas recomendadas y requisitos para administrar la capacidad

Tenga en cuenta lo siguiente al administrar la configuración de capacidad para tablas de réplica en


DynamoDB.

Uso de Auto Scaling de DynamoDB

El uso de Auto Scaling de DynamoDB es la forma recomendada de administrar la configuración de


capacidad de desempeño de las tablas de réplica que utilizan el modo provisionado. Auto Scaling de

Versión de API 2012-08-10


387
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

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.

Cambios en la configuración de escalado automático para una tabla de réplicas o


índice secundario realizados a través de la consola de DynamoDB o mediante la
herramientaUpdateGlobalTableSettingsse aplican automáticamente a todas las tablas de réplica
y a los índices secundarios coincidentes de la tabla global. Estos cambios sobrescriben cualquier
configuración de escala automática existente. Esto garantiza que la configuración de capacidad de
escritura aprovisionada sea coherente entre las tablas de réplica y los índices secundarios de la tabla
global. Si utiliza la opción deUpdateTable,RegisterScalableTarget, o bienPutScalingPolicy,
debe aplicar el cambio a cada tabla de réplica y al índice secundario coincidente individualmente.
Note

Si el escalado automático no satisface los cambios de capacidad de la aplicación (carga de


trabajo impredecible), o si no desea configurar sus opciones (configuración de destino para el
umbral mínimo, máximo o de utilización), puede usar el modo bajo demanda para administrar
la capacidad de las tablas globales. Para obtener más información, consulte Modo bajo
demanda (p. 18).
Si habilita el modo bajo demanda en una tabla global, el consumo de unidades de solicitud de
escritura replicada (RWCU) será coherente con la forma en que se aprovisionan las RCU. Por
ejemplo, si realiza 10 escrituras en una tabla local que se replica en dos Regiones adicionales,
consumirá 60 unidades de solicitud de escritura (10 + 10 + 10 = 30; 30 x 2 = 60). Las 60
unidades de solicitud de escritura consumidas incluyen la escritura adicional consumida por
las tablas globales versión 2017.11.29 para actualizar los atributos aws:rep:deleting,
aws:rep:updatetime y aws:rep:updateregion.

Administración manual de la capacidad

Si decide no utilizar Auto Scaling de DynamoDB, debe ajustar manualmente la configuración de la


capacidad de lectura y escritura en cada tabla de réplica e índice secundario.

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

Para actualizar la configuración de capacidad de escritura de la tabla global, recomendamos


encarecidamente utilizar la consola de DynamoDB o laUpdateGlobalTableSettingsOperación
API.UpdateGlobalTableSettingsaplica cambios a la configuración de capacidad de escritura a todas
las tablas de réplica y a los índices secundarios coincidentes de una tabla global automáticamente. Si
utiliza la opción deUpdateTable,RegisterScalableTarget, o bienPutScalingPolicy, debe aplicar
el cambio a cada tabla de réplicas y al índice secundario coincidente individualmente. Para obtener más
información, consulteReferencia de la API de Amazon DynamoDB.
Note

Para actualizar la configuración (UpdateGlobalTableSettings) para una tabla global en


DynamoDB, debe

Versión de API 2012-08-10


388
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

tenerdynamodb:UpdateGlobalTable,dynamodb:DescribeLimits,application-
autoscaling:DeleteScalingPolicy, yapplication-
autoscaling:DeregisterScalableTargetPermisos. Para obtener más información,
consulte Usar IAM con tablas globales (p. 392).

Crear una tabla global

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)

Crear una tabla global (consola)

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.

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/home. Para realizar


este ejemplo, elija la región us-east-2 (EE. UU. Este [Ohio]).
2. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas).
3. Seleccione Create Table (Crear tabla).

En Table name (Nombre de la tabla), introduzca Music.

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

Versión de API 2012-08-10


389
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

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.

Repita esto para EE. UU. Oeste (Oregón).

Creación de una tabla global (AWS CLI)

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

aws dynamodb create-table \


--table-name Music \
--attribute-definitions \
AttributeName=Artist,AttributeType=S \
AttributeName=SongTitle,AttributeType=S \
--key-schema \
AttributeName=Artist,KeyType=HASH \
AttributeName=SongTitle,KeyType=RANGE \
--provisioned-throughput \
ReadCapacityUnits=10,WriteCapacityUnits=5 \
--stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES \
--region us-east-2

2. Creación de unMusicEn EE. UU. Este (Norte de Virginia).

aws dynamodb create-table \


--table-name Music \
--attribute-definitions \
AttributeName=Artist,AttributeType=S \
AttributeName=SongTitle,AttributeType=S \
--key-schema \
AttributeName=Artist,KeyType=HASH \
AttributeName=SongTitle,KeyType=RANGE \
--provisioned-throughput \
ReadCapacityUnits=10,WriteCapacityUnits=5 \
--stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES \
--region us-east-1

3. Cree una tabla global (Music) que consiste en tablas de réplicas en elus-east-2yus-
east-1Regiones de.

aws dynamodb create-global-table \


--global-table-name Music \
--replication-group RegionName=us-east-2 RegionName=us-east-1 \
--region us-east-2

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.

aws dynamodb create-table \


--table-name Music \
--attribute-definitions \
AttributeName=Artist,AttributeType=S \
AttributeName=SongTitle,AttributeType=S \
--key-schema \
AttributeName=Artist,KeyType=HASH \
AttributeName=SongTitle,KeyType=RANGE \
--provisioned-throughput \
ReadCapacityUnits=10,WriteCapacityUnits=5 \
--stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES \
--region eu-west-1

Después de realizar este paso, agregue la nueva tabla a laMusictabla global.

aws dynamodb update-global-table \


--global-table-name Music \
--replica-updates 'Create={RegionName=eu-west-1}' \
--region us-east-2

5. Para comprobar que la replicación funciona, añada un nuevo elemento alMusicEn EE. UU. Este
(Ohio).

aws dynamodb put-item \


--table-name Music \
--item '{"Artist": {"S":"item_1"},"SongTitle": {"S":"Song Value 1"}}' \
--region us-east-2

6. Espere unos segundos y, a continuación, compruebe si el elemento se replicó correctamente en los


Estados Unidos Este (Norte de Virginia) y Europa (Irlanda).

aws dynamodb get-item \


--table-name Music \
--key '{"Artist": {"S":"item_1"},"SongTitle": {"S":"Song Value 1"}}' \
--region us-east-1

aws dynamodb get-item \


--table-name Music \
--key '{"Artist": {"S":"item_1"},"SongTitle": {"S":"Song Value 1"}}' \
--region eu-west-1

Monitoreo de tablas globales

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.

• ReplicationLatency: el tiempo transcurrido entre el momento en que un elemento actualizado


aparece en el flujo de DynamoDB para una tabla de réplica y el momento en que dicho elemento
Versión de API 2012-08-10
391
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

aparece en otra réplica de la tabla global.ReplicationLatencyse expresa en milisegundos y se emite


para cada uno de los pares de región de origen y destino.

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

ReplicationLatencypuede aumentar si unAWSLa región se encuentra degradada y tiene una tabla


de réplica en esa región. En este caso, puede redirigir temporalmente la actividad de lectura y escritura
de la aplicación a otraAWSRegión .
• PendingReplicationCount: el número de actualizaciones de elementos que se escriben
en una tabla de réplica pero que todavía no se han escrito en otra réplica de la tabla
global.PendingReplicationCountse expresa en el número de elementos y se emite para cada uno
de los pares de región de origen y destino.

Durante el funcionamiento normal,PendingReplicationCountDebería ser muy bajo.


SiPendingReplicationCountSi el valor de aumenta durante periodos prolongados de tiempo,
investigue si la configuración de la capacidad de escritura provisionada de las tablas de réplica es
suficiente para la carga de trabajo

PendingReplicationCountpuede aumentar si unAWSLa región se encuentra degradada y tiene


una tabla de réplica en esa región. En este caso, puede redirigir temporalmente la actividad de lectura y
escritura de la aplicación a otraAWSRegión .

Para obtener más información, consulte Dimensiones y métricas de DynamoDB (p. 940).

Usar IAM con tablas globales

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:

• La tabla de réplica que desea agregar.


• Cada réplica existente que ya forme parte de la tabla global.
• La misma tabla global.

Versión de API 2012-08-10


392
Amazon DynamoDB Guía para desarrolladores
Uso de tablas globales

Para actualizar la configuración (UpdateGlobalTableSettings) para una tabla global en DynamoDB,


debe tenerdynamodb:UpdateGlobalTable,dynamodb:DescribeLimits,application-
autoscaling:DeleteScalingPolicy, yapplication-
autoscaling:DeregisterScalableTargetPermisos.

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.

Ejemplo: Permitir la acción CreateGlobalTable

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": "*"
}
]
}

Ejemplo: Permitir las acciones UpdateGlobalTable, DescribeLimits, Application-


AutoScaling:DeletEscalingPolicy y Application-AutoScaling:Anular RegisterScalableTarget

Para actualizar la configuración (UpdateGlobalTableSettings) para una tabla global en DynamoDB,


debe tenerdynamodb:UpdateGlobalTable,dynamodb:DescribeLimits,application-
autoscaling:DeleteScalingPolicy, yapplication-
autoscaling:DeregisterScalableTargetPermisos.

La siguiente política de IAM concede permisos para permitir que elUpdateGlobalTableSettingsen


todas las tablas.

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:UpdateGlobalTable",
"dynamodb:DescribeLimits",

Versión de API 2012-08-10


393
Amazon DynamoDB Guía para desarrolladores
Etiquetado de recursos de

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

Agregar etiquetas a los recursos


Puede etiquetar los recursos de Amazon DynamoDB medianteetiquetas. Las etiquetas le permiten
categorizar los recursos de distintas maneras; por ejemplo, según su finalidad, propietario, entorno u otro
criterio. Las etiquetas pueden ayudar a hacer lo siguiente:

• Identificar rápidamente un recurso según las etiquetas que le haya asignado.


• ConsulteAWSLas facturas desglosadas por etiquetas.
Note

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.

Para empezar a usar etiquetas, haga lo siguiente:

1. Comprender Restricciones de etiquetado en DynamoDB (p. 395).


2. Crear etiquetas mediante Etiquetado de recursos en DynamoDB (p. 395).
3. UsarInformes de asignación de costos (p. 397)Para realizar un seguimiento deAWSCostos por
etiqueta activa.

Por último, es conveniente seguir estrategias de etiquetado óptimas. Para obtener información,
consulteAWSEstrategias de etiquetado.

Versión de API 2012-08-10


394
Amazon DynamoDB Guía para desarrolladores
Etiquetado de recursos de

Restricciones de etiquetado en DynamoDB


Cada etiqueta consta de una clave y un valor, ambos definidos por el usuario. Se aplican las siguientes
restricciones:

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

Etiquetado de recursos en DynamoDB


Puede utilizar la consola de Amazon DynamoDB o elAWS Command Line Interface(AWS CLI) para
agregar, enumerar, editar o eliminar etiquetas. A continuación, puede activar estas etiquetas definidas
por el usuario de modo que aparezcan en la consola de AWS Billing and Cost Management y así poder
usarlas para el seguimiento de asignación de costos. Para obtener más información, consulte Informes de
asignación de costos (p. 397).

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)

Establecer permisos para filtrar por etiquetas


Para utilizar etiquetas para filtrar la lista de tablas en la consola de DynamoDB, asegúrese de que las
directivas de usuario de IAM incluyan acceso a las siguientes operaciones:

• tag:GetTagKeys
• tag:GetTagValues

Versión de API 2012-08-10


395
Amazon DynamoDB Guía para desarrolladores
Etiquetado de recursos de

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.

1. Vaya a laConsola de IAMCon un usuario administrador.


2. Seleccione «Políticas» en el menú de navegación izquierdo.
3. Seleccione «Crear política».
4. Pegue la siguiente política en el editor JSON.

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"tag:GetTagKeys",
"tag:GetTagValues"
],
"Resource": "*"
}
]
}

5. Complete el asistente y asigne un nombre a la política (por


ejemplo,TagKeysAndValuesReadAccess).
6. En el menú de navegación izquierdo, seleccione «Usuarios».
7. En la lista, seleccione el usuario que utiliza habitualmente para obtener acceso a la consola de
DynamoDB.
8. Seleccione «Add permissions».
9. Seleccione Attach existing policies directly (Asociar directamente las políticas
10. En la lista, seleccione la política que ha creado anteriormente.
11. Complete el asistente.

Agregar etiquetas a tablas nuevas o existentes (AWS Management Console)


Puede utilizar la consola de DynamoDB para añadir etiquetas a tablas nuevas cuando las cree, o para
añadir, editar o eliminar etiquetas de tablas existentes.

Para etiquetar recursos al crearlos (consola)

1. Inicie sesión en laAWS Management Consoley abra la consola de DynamoDB enhttps://


console.aws.amazon.com/dynamodb/.
2. En el panel de navegación, elija Tables (Tablas) y, a continuación, seleccione Create table (Crear
tabla).
3. En la página Create DynamoDB table (Crear tabla de DynamoDB), proporcione un nombre y una clave
principal. SeleccionarAgregue etiquetasPara ello, escriba las etiquetas que desee usar.

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

Para etiquetar recursos existentes (consola)

Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.

Versión de API 2012-08-10


396
Amazon DynamoDB Guía para desarrolladores
Etiquetado de recursos de

1. En el panel de navegación, elija Tables (Tablas).


2. Elija una tabla de la lista y, a continuación, elija la pestaña Tags (Etiquetas) para añadir, editar o
eliminar las etiquetas.

Agregar etiquetas a tablas nuevas o existentes (AWS CLI)


En los ejemplos siguientes se muestra cómo usar la AWS CLI para especificar etiquetas al crear tablas e
índices, así como para etiquetar recursos existentes.

Para etiquetar recursos al crearlos (AWS CLI)

• En el ejemplo siguiente se crea una nueva tabla de Movies y se añade la etiqueta Owner con un valor
de blueTeam:

aws dynamodb create-table \


--table-name Movies \
--attribute-definitions AttributeName=Title,AttributeType=S \
--key-schema AttributeName=Title,KeyType=HASH \
--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
--tags Key=Owner,Value=blueTeam

Para etiquetar recursos existentes (AWS CLI)

• En el ejemplo siguiente se añade la etiqueta Owner con un valor de blueTeam para la tabla Movies:

aws dynamodb tag-resource \


--resource-arn arn:aws:dynamodb:us-east-1:123456789012:table/Movies \
--tags Key=Owner,Value=blueTeam

Para enumerar todas las etiquetas de una tabla (AWS CLI)

• En el ejemplo siguiente se muestran todas las etiquetas asociadas con la tabla Movies:

aws dynamodb list-tags-of-resource \


--resource-arn arn:aws:dynamodb:us-east-1:123456789012:table/Movies

Informes de asignación de costos


AWSutiliza etiquetas para organizar los costos de los recursos en el informe de asignación de
costos.AWSProporciona dos tipos de etiquetas de asignación de costos:

• UnaAWSEtiquetas generadas por.AWS: define, crea y aplica estas etiquetas automáticamente.


• Etiquetas definidas por el usuario. Usted puede definir, crear y aplicar estas etiquetas.

Debe activar ambos tipos de etiquetas por separado para que puedan aparecer en Cost Explorer o en un
informe de asignación de costos.

Para activarAWSEtiquetas generadas por:

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.

Versión de API 2012-08-10


397
Amazon DynamoDB Guía para desarrolladores
Uso de tablas: Java

3. UNDERAWSEtiquetas de asignación de costos generadas por, elijaActivate.

Para activar las etiquetas definidas por el usuario:

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.

Después de crear y activar etiquetas,AWSgenera un informe de asignación de costos con el uso y


los costos agrupados según las etiquetas activas. El informe de asignación de costos incluye todos
losAWSPara cada periodo de facturación. El informe incluye tanto recursos etiquetados como sin etiquetar,
para que pueda organizar con claridad los cargos de los recursos.
Note

En la actualidad, los datos transferidos desde DynamoDB no se desglosan según las etiquetas en
los informes de asignación de costos.

Para obtener más información, consulte Uso de etiquetas de asignación de costos.

Uso de tablas de DynamoDB en Java


Puede utilizar laAWS SDK for JavaPara crear, actualizar y eliminar tablas de Amazon DynamoDB,
enumerar todas las tablas de la cuenta u obtener información sobre una tabla concreta.

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)

Creación de una tabla


Para crear una tabla, debe proporcionar el nombre de la tabla, su clave principal y los valores de
rendimiento aprovisionado. En el siguiente fragmento de código se crea un ejemplo de tabla que utiliza un
identificador de atributo de tipo numérico como clave principal.

Para crear una tabla con la API del AWS SDK for Java

1. Cree una instancia de la clase DynamoDB.


2. Cree una instancia de CreateTableRequest para proporcionar la información de solicitud.

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.

En el siguiente ejemplo de código se ponen en práctica los pasos anteriores.

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();

Versión de API 2012-08-10


398
Amazon DynamoDB Guía para desarrolladores
Uso de tablas: Java

DynamoDB dynamoDB = new DynamoDB(client);

List<AttributeDefinition> attributeDefinitions= new ArrayList<AttributeDefinition>();


attributeDefinitions.add(new
AttributeDefinition().withAttributeName("Id").withAttributeType("N"));

List<KeySchemaElement> keySchema = new ArrayList<KeySchemaElement>();


keySchema.add(new KeySchemaElement().withAttributeName("Id").withKeyType(KeyType.HASH));

CreateTableRequest request = new CreateTableRequest()


.withTableName(tableName)
.withKeySchema(keySchema)
.withAttributeDefinitions(attributeDefinitions)
.withProvisionedThroughput(new ProvisionedThroughput()
.withReadCapacityUnits(5L)
.withWriteCapacityUnits(6L));

Table table = dynamoDB.createTable(request);

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

System.out.printf("%s: %s \t ReadCapacityUnits: %d \t WriteCapacityUnits: %d",


tableDescription.getTableStatus(),
tableDescription.getTableName(),
tableDescription.getProvisionedThroughput().getReadCapacityUnits(),
tableDescription.getProvisionedThroughput().getWriteCapacityUnits());

Puede llamar al método describe del cliente para obtener información sobre la tabla en cualquier
momento.

Example

TableDescription tableDescription = dynamoDB.getTable(tableName).describe();

Actualización de una tabla


Solamente se pueden actualizar los valores de rendimiento aprovisionado de una tabla existente. Según
los requisitos de su aplicación, es posible que tenga que actualizar estos valores.
Note

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

1. Cree una instancia de la clase Table.


2. Cree una instancia de la clase ProvisionedThroughput para proporcionar los nuevos valores de
desempeño.

Versión de API 2012-08-10


399
Amazon DynamoDB Guía para desarrolladores
Uso de tablas: Java

3. Ejecute laupdateTableal proporcionar el métodoProvisionedThroughputUna instancia de como


parámetro.

En el siguiente ejemplo de código se ponen en práctica los pasos anteriores.

Example

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("ProductCatalog");

ProvisionedThroughput provisionedThroughput = new ProvisionedThroughput()


.withReadCapacityUnits(15L)
.withWriteCapacityUnits(12L);

table.updateTable(provisionedThroughput);

table.waitForActive();

Eliminación de una tabla


Para eliminar una tabla con la API del AWS SDK for Java

1. Cree una instancia de la clase Table.


2. Cree una instancia de la clase DeleteTableRequest y proporcione el nombre de la tabla que desea
eliminar.
3. Ejecute ladeleteTableal proporcionar el métodoTableUna instancia de como parámetro.

En el siguiente ejemplo de código se ponen en práctica los pasos anteriores.

Example

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("ProductCatalog");

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

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB dynamoDB = new DynamoDB(client);

TableCollection<ListTablesResult> tables = dynamoDB.listTables();


Iterator<Table> iterator = tables.iterator();

Versión de API 2012-08-10


400
Amazon DynamoDB Guía para desarrolladores
Uso de tablas: Java

while (iterator.hasNext()) {
Table table = iterator.next();
System.out.println(table.getTableName());
}

Ejemplo: Creación, actualización, eliminación y enumeración de


tablas mediante elAWS SDK for JavaDocumentación de la API
En el ejemplo de código siguiente, se utiliza elAWS SDK for JavaDocumenta la API de para crear,
actualizar y eliminar una tabla de Amazon DynamoDB (ExampleTable). Durante la actualización de la
tabla, se aumentan los valores de desempeño provisionado. Además, en el ejemplo se enumeran todas
las tablas de la cuenta y se obtiene la descripción de una de ellas en particular. 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.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;

public class DocumentAPITableExample {

static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


static DynamoDB dynamoDB = new DynamoDB(client);

static String tableName = "ExampleTable";

public static void main(String[] args) throws Exception {

createExampleTable();
listMyTables();
getTableInformation();
updateExampleTable();

deleteExampleTable();

Versión de API 2012-08-10


401
Amazon DynamoDB Guía para desarrolladores
Uso de tablas: Java

static void createExampleTable() {

try {

List<AttributeDefinition> attributeDefinitions = new


ArrayList<AttributeDefinition>();
attributeDefinitions.add(new
AttributeDefinition().withAttributeName("Id").withAttributeType("N"));

List<KeySchemaElement> keySchema = new ArrayList<KeySchemaElement>();


keySchema.add(new
KeySchemaElement().withAttributeName("Id").withKeyType(KeyType.HASH)); // Partition

// key

CreateTableRequest request = new


CreateTableRequest().withTableName(tableName).withKeySchema(keySchema)
.withAttributeDefinitions(attributeDefinitions).withProvisionedThroughput(
new
ProvisionedThroughput().withReadCapacityUnits(5L).withWriteCapacityUnits(6L));

System.out.println("Issuing CreateTable request for " + tableName);


Table table = dynamoDB.createTable(request);

System.out.println("Waiting for " + tableName + " to be created...this may take


a while...");
table.waitForActive();

getTableInformation();

}
catch (Exception e) {
System.err.println("CreateTable request failed for " + tableName);
System.err.println(e.getMessage());
}

static void listMyTables() {

TableCollection<ListTablesResult> tables = dynamoDB.listTables();


Iterator<Table> iterator = tables.iterator();

System.out.println("Listing table names");

while (iterator.hasNext()) {
Table table = iterator.next();
System.out.println(table.getTableName());
}
}

static void getTableInformation() {

System.out.println("Describing " + tableName);

TableDescription tableDescription = dynamoDB.getTable(tableName).describe();


System.out.format(
"Name: %s:\n" + "Status: %s \n" + "Provisioned Throughput (read capacity units/
sec): %d \n"
+ "Provisioned Throughput (write capacity units/sec): %d \n",
tableDescription.getTableName(), tableDescription.getTableStatus(),
tableDescription.getProvisionedThroughput().getReadCapacityUnits(),
tableDescription.getProvisionedThroughput().getWriteCapacityUnits());
}

Versión de API 2012-08-10


402
Amazon DynamoDB Guía para desarrolladores
Uso de tablas: .NET

static void updateExampleTable() {

Table table = dynamoDB.getTable(tableName);


System.out.println("Modifying provisioned throughput for " + tableName);

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

static void deleteExampleTable() {

Table table = dynamoDB.getTable(tableName);


try {
System.out.println("Issuing DeleteTable request for " + tableName);
table.delete();

System.out.println("Waiting for " + tableName + " to be deleted...this may take


a while...");

table.waitForDelete();
}
catch (Exception e) {
System.err.println("DeleteTable request failed for " + tableName);
System.err.println(e.getMessage());
}
}

Uso de tablas de DynamoDB en .NET


Puede utilizar AWS SDK for .NET para crear, actualizar y eliminar tablas, enumerar todas las tablas de la
cuenta u obtener información sobre una tabla concreta.

A continuación se indican los pasos comunes para las operaciones con tablas de Amazon DynamoDB
mediante laAWS SDK for .NET.

1. Cree una instancia de la clase AmazonDynamoDBClient (el cliente).


2. Cree los objetos de solicitud correspondientes para proporcionar los parámetros obligatorios y
opcionales de la operación.

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.

Versión de API 2012-08-10


403
Amazon DynamoDB Guía para desarrolladores
Uso de tablas: .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)

Creación de una tabla


Para crear una tabla, debe proporcionar el nombre de la tabla, su clave principal y los valores de
rendimiento aprovisionado.

Para crear una tabla utilizando la API de bajo nivel del AWS SDK for .NET

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree una instancia de la clase CreateTableRequest para proporcionar la información de solicitud.

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.

En el siguiente ejemplo de C# se ponen en práctica los pasos anteriores. En el ejemplo se crea


una tabla (ProductCatalog) que utiliza el Id como clave principal y un conjunto de valores de
rendimiento aprovisionado. Según los requisitos de aplicación, puede actualizar los valores de rendimiento
aprovisionado mediante la API UpdateTable.

AmazonDynamoDBClient client = new AmazonDynamoDBClient();


string tableName = "ProductCatalog";

var request = new CreateTableRequest


{
TableName = tableName,
AttributeDefinitions = new List<AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = "N"
}
},
KeySchema = new List<KeySchemaElement>()
{
new KeySchemaElement
{
AttributeName = "Id",
KeyType = "HASH" //Partition key
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 5
}
};

var response = client.CreateTable(request);

Versión de API 2012-08-10


404
Amazon DynamoDB Guía para desarrolladores
Uso de tablas: .NET

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

var result = response.CreateTableResult;


var tableDescription = result.TableDescription;
Console.WriteLine("{1}: {0} \t ReadCapacityUnits: {2} \t WriteCapacityUnits: {3}",
tableDescription.TableStatus,
tableDescription.TableName,
tableDescription.ProvisionedThroughput.ReadCapacityUnits,
tableDescription.ProvisionedThroughput.WriteCapacityUnits);

string status = tableDescription.TableStatus;


Console.WriteLine(tableName + " - " + status);

También puede llamar al método DescribeTable del cliente para obtener información sobre la tabla en
cualquier momento.

Example

var res = client.DescribeTable(new DescribeTableRequest{TableName = "ProductCatalog"});

Actualización de una tabla


Solamente se pueden actualizar los valores de rendimiento aprovisionado de una tabla existente. Según
los requisitos de su aplicación, es posible que tenga que actualizar estos valores.
Note

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

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree una instancia de la clase UpdateTableRequest para proporcionar la información de solicitud.

Debe proporcionar el nombre de la tabla y los nuevos valores de rendimiento aprovisionado.


3. Ejecute laAmazonDynamoDBClient.UpdateTableproporcionando el objeto de solicitud como
parámetro.

En el siguiente ejemplo de C# se ponen en práctica los pasos anteriores.

Example

AmazonDynamoDBClient client = new AmazonDynamoDBClient();


string tableName = "ExampleTable";

var request = new UpdateTableRequest()


{
TableName = tableName,
ProvisionedThroughput = new ProvisionedThroughput()
{
// Provide new values.
ReadCapacityUnits = 20,

Versión de API 2012-08-10


405
Amazon DynamoDB Guía para desarrolladores
Uso de tablas: .NET

WriteCapacityUnits = 10
}
};
var response = client.UpdateTable(request);

Eliminación de una tabla


Siga estos pasos para eliminar una tabla mediante la API de bajo nivel de .NET.

Para eliminar una tabla utilizando la API de bajo nivel del AWS SDK for .NET

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree una instancia de la clase DeleteTableRequest y proporcione el nombre de la tabla que desea
eliminar.
3. Ejecute laAmazonDynamoDBClient.DeleteTableproporcionando el objeto de solicitud como
parámetro.

En el siguiente ejemplo de código C# se ponen en práctica los pasos anteriores.

Example

AmazonDynamoDBClient client = new AmazonDynamoDBClient();


string tableName = "ExampleTable";

var request = new DeleteTableRequest{ TableName = tableName };


var response = client.DeleteTable(request);

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

AmazonDynamoDBClient client = new AmazonDynamoDBClient();

// Initial value for the first page of table names.


string lastEvaluatedTableName = null;
do
{
// Create a request object to specify optional parameters.
var request = new ListTablesRequest
{
Limit = 10, // Page size.
ExclusiveStartTableName = lastEvaluatedTableName
};

var response = client.ListTables(request);


ListTablesResult result = response.ListTablesResult;

Versión de API 2012-08-10


406
Amazon DynamoDB Guía para desarrolladores
Uso de tablas: .NET

foreach (string name in result.TableNames)


Console.WriteLine(name);

lastEvaluatedTableName = result.LastEvaluatedTableName;

} while (lastEvaluatedTableName != null);

Ejemplo: Creación, actualización, eliminación y enumeración de


tablas mediante elAWS SDK for .NETAPI de bajo nivel
En el siguiente ejemplo de C# se crea, actualiza y elimina una tabla (ExampleTable). Además, se
enumeran todas las tablas de la cuenta y se obtiene la descripción de una de ellas en particular. Al
actualizar la tabla, se aumentan los valores de rendimiento aprovisionado. Para obtener instrucciones paso
a paso sobre cómo realizar las pruebas del ejemplo siguiente, 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 LowLevelTableExample
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
private static string tableName = "ExampleTable";

static void Main(string[] args)


{
try
{
CreateExampleTable();
ListMyTables();
GetTableInformation();
UpdateExampleTable();

DeleteExampleTable();

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

private static void CreateExampleTable()


{

Versión de API 2012-08-10


407
Amazon DynamoDB Guía para desarrolladores
Uso de tablas: .NET

Console.WriteLine("\n*** Creating table ***");


var request = new CreateTableRequest
{
AttributeDefinitions = new List<AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = "N"
},
new AttributeDefinition
{
AttributeName = "ReplyDateTime",
AttributeType = "N"
}
},
KeySchema = new List<KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "Id",
KeyType = "HASH" //Partition key
},
new KeySchemaElement
{
AttributeName = "ReplyDateTime",
KeyType = "RANGE" //Sort key
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 5,
WriteCapacityUnits = 6
},
TableName = tableName
};

var response = client.CreateTable(request);

var tableDescription = response.TableDescription;


Console.WriteLine("{1}: {0} \t ReadsPerSec: {2} \t WritesPerSec: {3}",
tableDescription.TableStatus,
tableDescription.TableName,
tableDescription.ProvisionedThroughput.ReadCapacityUnits,
tableDescription.ProvisionedThroughput.WriteCapacityUnits);

string status = tableDescription.TableStatus;


Console.WriteLine(tableName + " - " + status);

WaitUntilTableReady(tableName);
}

private static void ListMyTables()


{
Console.WriteLine("\n*** listing tables ***");
string lastTableNameEvaluated = null;
do
{
var request = new ListTablesRequest
{
Limit = 2,
ExclusiveStartTableName = lastTableNameEvaluated
};

var response = client.ListTables(request);


foreach (string name in response.TableNames)

Versión de API 2012-08-10


408
Amazon DynamoDB Guía para desarrolladores
Uso de tablas: .NET

Console.WriteLine(name);

lastTableNameEvaluated = response.LastEvaluatedTableName;
} while (lastTableNameEvaluated != null);
}

private static void GetTableInformation()


{
Console.WriteLine("\n*** Retrieving table information ***");
var request = new DescribeTableRequest
{
TableName = tableName
};

var response = client.DescribeTable(request);

TableDescription description = response.Table;


Console.WriteLine("Name: {0}", description.TableName);
Console.WriteLine("# of items: {0}", description.ItemCount);
Console.WriteLine("Provision Throughput (reads/sec): {0}",
description.ProvisionedThroughput.ReadCapacityUnits);
Console.WriteLine("Provision Throughput (writes/sec): {0}",
description.ProvisionedThroughput.WriteCapacityUnits);
}

private static void UpdateExampleTable()


{
Console.WriteLine("\n*** Updating table ***");
var request = new UpdateTableRequest()
{
TableName = tableName,
ProvisionedThroughput = new ProvisionedThroughput()
{
ReadCapacityUnits = 6,
WriteCapacityUnits = 7
}
};

var response = client.UpdateTable(request);

WaitUntilTableReady(tableName);
}

private static void DeleteExampleTable()


{
Console.WriteLine("\n*** Deleting table ***");
var request = new DeleteTableRequest
{
TableName = tableName
};

var response = client.DeleteTable(request);

Console.WriteLine("Table is being deleted...");


}

private static void WaitUntilTableReady(string tableName)


{
string status = null;
// Let us wait until table is created. Call DescribeTable.
do
{
System.Threading.Thread.Sleep(5000); // Wait 5 seconds.
try
{
var res = client.DescribeTable(new DescribeTableRequest

Versión de API 2012-08-10


409
Amazon DynamoDB Guía para desarrolladores
Uso de elementos

{
TableName = tableName
});

Console.WriteLine("Table name: {0}, status: {1}",


res.Table.TableName,
res.Table.TableStatus);
status = res.Table.TableStatus;
}
catch (ResourceNotFoundException)
{
// DescribeTable is eventually consistent. So you might
// get resource not found. So we handle the potential exception.
}
} while (status != "ACTIVE");
}
}
}

Uso de elementos y atributos


En Amazon DynamoDB, unelementoes una colección de atributos. Cada atributo tiene un nombre y un
valor. Los valores de los atributos pueden ser escalares, conjuntos o tipos de documentos. Para obtener
más información, consulte Amazon DynamoDB: Cómo funciona (p. 2).

DynamoDB proporciona cuatro operaciones que aportan la funcionalidad básica de creación, lectura,
actualización y eliminación (CRUD):

• PutItem: permite crear un elemento.


• GetItem— Leer un elemento.
• UpdateItem: permite actualizar un elemento.
• DeleteItem: permite eliminar un elemento.

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:

• BatchGetItem: permite leer hasta 100 elementos de una o varias tablas.


• BatchWriteItem: permite crear o eliminar hasta 25 elementos en una o varias tablas.

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)

Versión de API 2012-08-10


410
Amazon DynamoDB Guía para desarrolladores
Lectura de un elemento

• Escrituras condicionales (p. 416)


• Uso de expresiones en DynamoDB (p. 421)
• Vencimiento de elementos mediante el uso de tiempo de vida (TL) de DynamoDB (p. 446)
• Uso de elementos: Java (p. 453)
• Uso de elementos: .NET (p. 474)

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.

aws dynamodb get-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"1"}}'

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.

aws dynamodb get-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"1"}}' \
--consistent-read \
--projection-expression "Description, Price, RelatedItems" \
--return-consumed-capacity TOTAL

Escritura de un elemento
Para crear, actualizar o eliminar un elemento de una tabla de DynamoDB, utilice una de las siguientes
operaciones:

• PutItem
• UpdateItem

Versión de API 2012-08-10


411
Amazon DynamoDB Guía para desarrolladores
Escritura de un elemento

• 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:

• TOTAL: devuelve el número total de unidades de capacidad de escritura consumidas.


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

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

aws dynamodb put-item \


--table-name Thread \
--item file://item.json

Los argumentos de --item se almacenan en el archivo item.json.

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

En la expresión de actualización, se utilizan valores de atributos de expresión como marcadores de


posición de los valores reales. Para obtener más información, consulte Valores de los atributos de
expresión (p. 428).

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

Versión de API 2012-08-10


412
Amazon DynamoDB Guía para desarrolladores
Valores devueltos

aws dynamodb update-item \


--table-name Thread \
--key file://key.json \
--update-expression "SET Answered = :zero, Replies = :zero, LastPostedBy
= :lastpostedby" \
--expression-attribute-values file://expression-attribute-values.json \
--return-values ALL_NEW

Los argumentos de --key se almacenan en el archivo key.json.

{
"ForumName": {"S": "Amazon DynamoDB"},
"Subject": {"S": "New discussion thread"}
}

Los argumentos de --expression-attribute-values se almacenan en el archivo expression-


attribute-values.json.

{
":zero": {"N":"0"},
":lastpostedby": {"S":"barney@example.com"}
}

DeleteItem
DeleteItem elimina el elemento con la clave especificada.

Example

En el ejemplo siguiente de la AWS CLI, se muestra cómo eliminar el elemento Thread.

aws dynamodb delete-item \


--table-name Thread \
--key file://key.json

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.

El valor predeterminado deReturnValuesesNONE, es decir, DynamoDB no devuelve ninguna información


sobre los atributos modificados.

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.

Versión de API 2012-08-10


413
Amazon DynamoDB Guía para desarrolladores
Operaciones por lotes

• Si escribe un elemento que no existía, ALL_OLD no surte efecto.

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.

Operaciones por lotes


Para las aplicaciones que requieren leer o escribir varios elementos, DynamoDB proporciona
elBatchGetItemyBatchWriteItemoperaciones. Con estas operaciones se puede reducir el número de
recorridos de ida y vuelta a través de la red entre la aplicación y DynamoDB. Además, DynamoDB lleva a
cabo las operaciones de lectura y escritura individuales en paralelo. Las aplicaciones se benefician de este
procesamiento en paralelo sin tener que administrar la concurrencia ni los subprocesos.

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.

aws dynamodb batch-get-item \


--request-items file://request-items.json

Los argumentos de --request-items se almacenan en el archivo request-items.json.

{
"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

BatchWriteItem no admite las solicitudes UpdateItem.

Example

Escriba dos elementos en la tabla ProductCatalog.

aws dynamodb batch-write-item \


--request-items file://request-items.json

Los argumentos de --request-items se almacenan en el archivo request-items.json.

{
"ProductCatalog": [
{
"PutRequest": {
"Item": {
"Id": { "N": "601" },

Versión de API 2012-08-10


415
Amazon DynamoDB Guía para desarrolladores
Contadores atómicos

"Description": { "S": "Snowboard" },


"QuantityOnHand": { "N": "5" },
"Price": { "N": "100" }
}
}
},
{
"PutRequest": {
"Item": {
"Id": { "N": "602" },
"Description": { "S": "Snow shovel" }
}
}
}
]
}

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

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id": { "N": "601" }}' \
--update-expression "SET Price = Price + :incr" \
--expression-attribute-values '{":incr":{"N":"5"}}' \
--return-values UPDATED_NEW

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

Versión de API 2012-08-10


416
Amazon DynamoDB Guía para desarrolladores
Escrituras condicionales

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.

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"1"}}' \
--update-expression "SET Price = :newval" \
--expression-attribute-values file://expression-attribute-values.json

Los argumentos de --expression-attribute-values se almacenan en el archivo expression-


attribute-values.json:

Versión de API 2012-08-10


417
Amazon DynamoDB Guía para desarrolladores
Escrituras condicionales

{
":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.

Versión de API 2012-08-10


418
Amazon DynamoDB Guía para desarrolladores
Escrituras condicionales

Alice intenta actualizar el valor de Price a 8, pero solamente si el valor de Price actual es 10.

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"1"}}' \
--update-expression "SET Price = :newval" \
--condition-expression "Price = :currval" \
--expression-attribute-values file://expression-attribute-values.json

Los argumentos de --expression-attribute-values se almacenan en el archivo expression-


attribute-values.json.

{
":newval":{"N":"8"},
":currval":{"N":"10"}
}

Versión de API 2012-08-10


419
Amazon DynamoDB Guía para desarrolladores
Escrituras condicionales

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.

Para obtener más información, consulte Expresiones de condición (p. 428).

Idempotencia de las escrituras condicionales


Las escrituras condicionales pueden ser idempotentes si la comprobación adicional está en el mismo
atributo que se va a actualizar. Esto significa que DynamoDB realiza una determinada solicitud de escritura
si determinados valores de atributos del elemento coinciden con lo que se espera que sean en el momento
de la solicitud.

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.

Unidades de capacidad consumidas por las escrituras


condicionales
Si unaConditionExpressionevalúa en false durante una escritura condicional, DynamoDB consume
capacidad de escritura de la tabla:

• Si el elemento no existe actualmente en la tabla, DynamoDB consume una unidad de capacidad de


escritura.
• Si el elemento existe, el número de unidades de capacidad de escritura consumidas depende del
tamaño del elemento. 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 elemento es el doble, la
escritura condicional que no se ha llevado a cabo consumiría dos unidades de capacidad de escritura.

Note

Las operaciones de escritura solo consumen unidades de capacidad de escritura. Nunca


consumen unidades de capacidad de lectura.

Una escritura condicional que no se ha llevado a cabo devuelve la excepción


ConditionalCheckFailedException. Cuando esto ocurre, no se recibe ninguna información
en la respuesta sobre la capacidad de escritura que se ha consumido. Sin embargo, puede ver
elConsumedWriteCapacityUnitspara la tabla en Amazon CloudWatch. Para obtener más información,
consulte Métricas de DynamoDB (p. 940) en Registro y monitorización en DynamoDB (p. 938).

Para devolver el número de unidades de capacidad de escritura consumidas durante una escritura
condicional, se usa el parámetro ReturnConsumedCapacity:

• TOTAL: devuelve el número total de unidades de capacidad de escritura consumidas.

Versión de API 2012-08-10


420
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

• 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

A diferencia de un índice secundario global, un índice secundario local comparte su capacidad de


desempeño provisionada con su tabla. La actividad de lectura y escritura en un índice secundario
local consume capacidad de desempeño provisionada de la tabla.

Uso de expresiones en DynamoDB


En Amazon DynamoDB, utilizaexpresionesPara indicar los atributos que desea leer de un elemento.
Además, se pueden utilizar al escribir un elemento, para indicar las condiciones que se deben cumplir
(esto también se denomina una actualización condicional) y cómo se han de actualizar los atributos. En
esta sección se describen los aspectos gramaticales básicos de las expresiones y los tipos de expresiones
disponibles.
Note

Para ofrecer compatibilidad retroactiva, DynamoDB también admite parámetros condicionales


que no utilizan expresiones. Para obtener más información, consulte Parámetros condicionales
heredados (p. 1144).
Las nuevas aplicaciones deben utilizar expresiones en lugar de los parámetros heredados.

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)

Especificación de atributos de elemento al utilizar expresiones


En esta sección se describe cómo consultar los atributos de los elementos en una expresión en Amazon
DynamoDB. Puede utilizar cualquier atributo, aunque se encuentre anidado profundamente en varias listas
y mapas.

Temas
• Atributos de nivel superior (p. 422)
• Atributos anidados (p. 423)
• Rutas de documento (p. 423)

Ejemplo de elemento: ProductCatalog

Lo siguiente es una representación de un elementos en la tabla ProductCatalog. Esta tabla se describe


en Ejemplos de tablas y datos (p. 1080).

{
"Id": 123,
"Title": "Bicycle 123",

Versión de API 2012-08-10


421
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

"Description": "123 description",


"BicycleType": "Hybrid",
"Brand": "Brand-Company C",
"Price": 500,
"Color": ["Red", "Black"],
"ProductCategory": "Bicycle",
"InStock": true,
"QuantityOnHand": null,
"RelatedItems": [
341,
472,
649
],
"Pictures": {
"FrontView": "http://example.com/products/123_front.jpg",
"RearView": "http://example.com/products/123_rear.jpg",
"SideView": "http://example.com/products/123_left_side.jpg"
},
"ProductReviews": {
"FiveStar": [
"Excellent! Can't recommend it highly enough! Buy it!",
"Do yourself a favor and buy this."
],
"OneStar": [
"Terrible product! Do not buy this."
]
},
"Comment": "This product sells out quickly during the summer",
"Safety.Warning": "Always wear a helmet"
}

Tenga en cuenta lo siguiente:

• El valor de la clave de partición (Id) es 123. No hay clave de ordenación.


• Los tipos de datos de la mayoría de los atributos son escalares, tales como String, Number, Boolean
y Null.
• Un atributo (Color) es de tipo String Set.
• Los siguientes atributos tienen tipos de datos de documento:
• Lista de RelatedItems. Cada componente es un Id de un producto relacionado.
• Mapa de imágenes (Pictures). Cada componente es una descripción breve de una imagen, junto
con una dirección URL del archivo de imagen correspondiente.
• Mapa de imágenes (ProductReviews). Cada componente representa una clasificación y una lista de
opiniones correspondientes a esa clasificación. Inicialmente, este mapa se rellena con opiniones de
cinco estrellas y una estrella.

Atributos de nivel superior


Se considera que un atributo es de nivel superior si no está integrado en otro atributo. En el elemento
ProductCatalog, los atributos de nivel superior son:

• Id
• Title
• Description
• BicycleType
• Brand
• Price
• Color

Versión de API 2012-08-10


422
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

• 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:

• [n]: para entradas de lista


• .(punto): para entradas de mapa

Acceso a las entradas de lista

El operador de desreferenciación de una entrada de lista es [n], donde n es el número de entrada.


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. Estos son algunos ejemplos:

• MyList[0]
• AnotherList[12]
• ThisList[5][11]

La entrada ThisList[5] es una lista anidada en sí misma. Por consiguiente, ThisList[5][11] se


refiere al duodécimo componente de esa lista.

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]

Acceso a las entradas de un mapa

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.

Versión de API 2012-08-10


423
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

A continuación se indican algunos ejemplos de rutas de documentos. Consulte el elemento mostrado en


Especificación de atributos de elemento al utilizar expresiones (p. 421).

• Atributo escalar de nivel superior.

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.

A continuación se muestran ejemplos de expresiones de proyección basadas en el elemento


ProductCatalog de Especificación de atributos de elemento al utilizar expresiones (p. 421):

• Un solo atributo de nivel superior.

Title
• Tres atributos de nivel superior. DynamoDB recupera todo elColorSet.

Title, Price, Color


• Cuatro atributos de nivel superior. DynamoDB devuelve todo el contenido
deRelatedItemsyProductReviews.

Title, Description, RelatedItems, ProductReviews


Versión de API 2012-08-10
424
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

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

aws dynamodb get-item \


--table-name ProductCatalog \
--key file://key.json \
--projection-expression "Description, RelatedItems[0], ProductReviews.FiveStar"

Los argumentos de --key se almacenan en el archivo key.json.

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

Nombres de atributos de expresión en DynamoDB


UnaNombre de atributo de la expresiónes un marcador de posición que se utiliza en una expresión de
Amazon DynamoDB como alternativa a un nombre de atributo real. Un nombre de atributo de expresión
debe comenzar por un signo de almohadilla (#) y debe ir seguido de uno o más caracteres alfanuméricos.

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,

aws dynamodb get-item \


--table-name ProductCatalog \

Versión de API 2012-08-10


425
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

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

aws dynamodb get-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#c" \
--expression-attribute-names '{"#c":"Comment"}'

Note

Si un nombre de atributo comienza por un número o contiene un espacio, un carácter especial o


una palabra reservada, entonces es imprescindible utilizar un nombre de atributo de expresión
para sustituir el nombre de ese atributo en la expresión.

Nombres de atributo que contienen puntos


En una expresión, un punto (".") se interpreta como un carácter separador en una ruta de documento. Sin
embargo, DynamoDB también permite utilizar el punto como parte de un nombre de atributo. En algunos
casos, esto puede dar lugar a ambigüedades. A modo de ejemplo, supongamos que desea recuperar el
atributo Safety.Warning de un elemento ProductCatalog (consulte Especificación de atributos de
elemento al utilizar expresiones (p. 421)).

Supongamos que desea obtener acceso a Safety.Warning mediante una expresión de proyección.

aws dynamodb get-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "Safety.Warning"

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.

aws dynamodb get-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#sw" \
--expression-attribute-names '{"#sw":"Safety.Warning"}'

Ahora, DynamoDB devolvería el resultado correcto.

Atributos anidados
Supongamos que desea obtener acceso al atributo anidado ProductReviews.OneStar, utilizando la
siguiente expresión de proyección.

aws dynamodb get-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "ProductReviews.OneStar"

El resultado podría contener todas las opiniones sobre productos de una sola estrella, que es lo previsto.

Versión de API 2012-08-10


426
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

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?

aws dynamodb get-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#pr1star" \
--expression-attribute-names '{"#pr1star":"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

A continuación, habría que usar #pr.#1star para la expresión de proyección.

aws dynamodb get-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#pr.#1star" \
--expression-attribute-names '{"#pr":"ProductReviews", "#1star":"OneStar"}'

Ahora, DynamoDB devolvería el resultado correcto.

Repetición de nombres de atributos


Expresión los nombres de atributos de expresión resultan útiles cuando es preciso consultar repetidamente
el mismo nombre de atributo. Por ejemplo, tomemos la siguiente expresión para recuperar algunas de las
opiniones de un elemento de ProductCatalog.

aws dynamodb get-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "ProductReviews.FiveStar, ProductReviews.ThreeStar,
ProductReviews.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.

• #pr.FiveStar, #pr.ThreeStar, #pr.OneStar

aws dynamodb get-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#pr.FiveStar, #pr.ThreeStar, #pr.OneStar" \
--expression-attribute-names '{"#pr":"ProductReviews"}'

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

Versión de API 2012-08-10


427
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

Valores de los atributos de expresión


Si desea comparar un atributo con un valor, defina un valor de atributo de expresión como marcador de
posición. Valores del atributo de expresiónEn Amazon DynamoDB sustituyen a los valores reales que
se desea comparar, que podrían no conocerse hasta el tiempo de ejecución. Un valor de atributo de
expresión debe comenzar por un signo de dos puntos (:) y debe ir seguido de uno o más caracteres
alfanuméricos.

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

aws dynamodb scan \


--table-name ProductCatalog \
--filter-expression "contains(Color, :c) and Price <= :p" \
--expression-attribute-values file://values.json

Los argumentos de --expression-attribute-values se almacenan en el archivo values.json.

{
":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.

A continuación se muestran algunos ejemplos de uso de expresiones de condición en la AWS Command


Line Interface (AWS CLI). Estos ejemplos se basan en la tabla ProductCatalog, especificada en
Especificación de atributos de elemento al utilizar expresiones (p. 421). La clave de partición de esta
tabla es Id y no tiene clave de ordenación. La siguiente operación PutItem crea un elemento de muestra
ProductCatalog al que se refieren los ejemplos.

aws dynamodb put-item \


--table-name ProductCatalog \

Versión de API 2012-08-10


428
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

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

aws dynamodb put-item \


--table-name ProductCatalog \
--item file://item.json \
--condition-expression "attribute_not_exists(Id)"

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.

Considere el elemento de Expresiones de condición (p. 428).

{
"Id": {
"N": "456"
},
"Price": {
"N": "650"
},
"ProductCategory": {
"S": "Sporting Goods"
}
}

Suponga que desea eliminar el elemento, pero solo en las siguientes condiciones:

Versión de API 2012-08-10


429
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

• El valor de ProductCategory es "Sporting Goods" o "Gardening Supplies".


• El valor de Price está comprendido entre 500 y 600.

En el siguiente ejemplo se intenta eliminar el elemento.

aws dynamodb delete-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"456"}}' \
--condition-expression "(ProductCategory IN (:cat1, :cat2)) and (Price between :lo
and :hi)" \
--expression-attribute-values file://values.json

Los argumentos de --expression-attribute-values se almacenan en el archivo values.json.

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

En este ejemplo, la comparación de ProductCategory se evalúa en true, pero la comparación de Price


se evalúa en false. Esto hace que la expresión de condición se evalúe en false y, por consiguiente, la
operación DeleteItem no se lleva a cabo.

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.

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \

Versión de API 2012-08-10


430
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

--update-expression "SET Price = Price - :discount" \


--condition-expression "Price > :limit" \
--expression-attribute-values file://values.json

Los argumentos de --expression-attribute-values se almacenan en el archivo values.json.

{
":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 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 ">" y otros operadores, consulte Operador de comparación y
referencia de funciones (p. 433).

Ejemplos de expresiones condicionales


Para obtener más información acerca de las funciones utilizadas en los ejemplos siguientes, consulte
Operador de comparación y referencia de funciones (p. 433). Si desea obtener más información sobre
cómo especificar distintos tipos de atributo en una expresión, consulte Especificación de atributos de
elemento al utilizar expresiones (p. 421).

Comprobación de los atributos de un elemento


Puede comprobar la existencia (o inexistencia) de cualquier atributo. 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 siguiente ejemplo se utiliza attribute_not_exists para eliminar un producto únicamente si no


tiene el atributo Price.

aws dynamodb delete-item \


--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "attribute_not_exists(Price)"

DynamoDB también ofreceattribute_existsfunción. En el siguiente ejemplo se elimina un producto


únicamente si ha recibido opiniones negativas.

aws dynamodb delete-item \


--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "attribute_exists(ProductReviews.OneStar)"

Comprobación del tipo de atributo


Puede comprobar el tipo de datos de un valor de atributo mediante la función attribute_type. 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 attribute_type para eliminar un producto sólo si tiene un atributo
Color de tipo String Set.

Versión de API 2012-08-10


431
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

aws dynamodb delete-item \


--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "attribute_type(Color, :v_sub)" \
--expression-attribute-values file://expression-attribute-values.json

Los argumentos de --expression-attribute-values se almacenan en el archivo expression-


attribute-values.json.

{
":v_sub":{"S":"SS"}
}

Comprobación del valor inicial de cadena

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.

aws dynamodb delete-item \


--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "begins_with(Pictures.FrontView, :v_sub)" \
--expression-attribute-values file://expression-attribute-values.json

Los argumentos de --expression-attribute-values se almacenan en el archivo expression-


attribute-values.json.

{
":v_sub":{"S":"http://"}
}

Comprobación de un elemento en un conjunto

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.

aws dynamodb delete-item \


--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "contains(Color, :v_sub)" \
--expression-attribute-values file://expression-attribute-values.json

Los argumentos de --expression-attribute-values se almacenan en el archivo expression-


attribute-values.json.

{
":v_sub":{"S":"Red"}
}

Versión de API 2012-08-10


432
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

Comprobación del tamaño de un valor de atributo


Puede comprobar el tamaño de un valor de atributo mediante la función size. 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 size para eliminar un producto sólo si el tamaño del atributo Binary
VideoClip es mayor de 64000 bytes.

aws dynamodb delete-item \


--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "size(VideoClip) > :v_sub" \
--expression-attribute-values file://expression-attribute-values.json

Los argumentos de --expression-attribute-values se almacenan en el archivo expression-


attribute-values.json.

{
":v_sub":{"N":"64000"}
}

Operador de comparación y referencia de funciones


En esta sección se describen las funciones y las palabras clave integradas para escribir expresiones de
condición en Amazon DynamoDB.

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)

Sintaxis de las expresiones de condición


En el siguiente resumen de sintaxis, el componente operand puede ser uno de los siguientes:

• 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 ::=
=
| <>
| <
| <=

Versión de API 2012-08-10


433
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

| >
| >=

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:

• a = b: es true si a es igual que b.


• a <> b: es true si a es distinto de b.
• a < b: es true si a es menor que b.
• a <= b: es true si a es menor o igual que b.
• a > b: es true si a es mayor que b.
• a >= b: es true si a es mayor o igual que b.

Use las palabras clave BETWEEN e IN para comparar un operando con un rango o una lista de valores:

• a BETWEEN b AND c: es true si a es mayor o igual que b y menor o igual que c.


• a IN (b, c, d) : trueaEs igual a cualquier valor de la lista, por ejemplo, cualquiera de los valores
deb,cord. La lista puede contener hasta 100 valores separadas por comas.

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 (path) Es true si el elemento contiene el atributo


especificado por path.

Ejemplo: Comprobación de si un elemento en


elProducttiene una imagen de vista lateral.

• attribute_exists (Pictures.SideView)

attribute_not_exists (path) Es true si el atributo especificado en path no está


presente en el elemento.

Ejemplo: Comprobación de si un elemento


tieneManufactureratributo.

• attribute_not_exists (Manufacturer)

attribute_type (path, type) Es true si el atributo de la ruta especificada es de


un tipo de datos determinado. El parámetro type
debe ser uno de los siguientes:

• S — Cadena

Versión de API 2012-08-10


434
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

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

Debe utilizar un valor de atributo de expresión para


el parámetro type.

Ejemplo: Compruebe si elQuantityOnHandes de


tipo List. En este ejemplo, :v_sub es un marcador
de posición para la L.

• attribute_type
(ProductReviews.FiveStar, :v_sub)

Debe utilizar un valor de atributo de expresión para


el parámetro type.

begins_with (path, substr) Es true si el atributo especificado por path


comienza por una subcadena determinada.

Ejemplo: Comprobación de si los primeros


caracteres de la URL de la imagen de vista frontal
sonhttp://.

• begins_with
(Pictures.FrontView, :v_sub)

El valor de atributo de expresión :v_sub es un


marcador de posición para http://.

Versión de API 2012-08-10


435
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

Función Descripción

contains (path, operand) Es true si el atributo especificado por path es uno


de los siguientes:

• Un valor de tipo String que contiene una


determinada subcadena.
• Un valor de tipo Set que contiene un
componente determinado perteneciente al
conjunto.

Laoperanddebe ser unaStringSi el atributo


especificado porpathes unString. Si el atributo
especificado porpathes unSet, eloperanddebe
ser el tipo de elemento del conjunto.

La ruta y el operando deben ser únicos; es decir,


contains (a, a) devuelve un error.

Ejemplo: Compruebe si elBrandatributo contiene la


subcadenaCompany.

• contains (Brand, :v_sub)

El valor de atributo de expresión :v_sub es un


marcador de posición para Company.

Ejemplo: Comprobación de si el producto está


disponible en color rojo.

• contains (Color, :v_sub)

El valor de atributo de expresión :v_sub es un


marcador de posición para Red.

Versión de API 2012-08-10


436
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

Función Descripción

size (path) Devuelve un número que representa el tamaño de


un atributo. A continuación se muestran los tipos
de datos válidos para usarlos con size.

Si el atributo es de tipo String, size devuelve la


longitud de la cadena.

Ejemplo: Compruebe si la cadenaBrandes inferior


o igual a 20 caracteres. El valor de atributo de
expresión :v_sub es un marcador de posición
para 20.

• size (Brand) <= :v_sub

Si el atributo es de tipo Binary, size devuelve el


número de bytes del valor del atributo.

Ejemplo: Supongamos que


elProductCatalogelemento tiene un atributo
binario llamadoVideoClipEn el que se muestra
un breve vídeo sobre el uso del producto. En la
siguiente expresión se comprueba si VideoClip
supera los 64 000 bytes. El valor de atributo de
expresión :v_sub es un marcador de posición
para 64000.

• size(VideoClip) > :v_sub

Si el tipo de datos del atributo es Set, size


devuelve el número de componentes del conjunto.

Ejemplo: Comprobación de si el producto está


disponible en más de un color. El valor de atributo
de expresión :v_sub es un marcador de posición
para 1.

• size (Color) < :v_sub

Si el atributo es de tipo List o Map, size


devuelve el número de componentes secundarios.

Ejemplo: Compruebe si el número deOneStarLas


opiniones han superado un umbral determinado.
El valor de atributo de expresión :v_sub es un
marcador de posición para 3.

• size(ProductReviews.OneStar)
> :v_sub

Versión de API 2012-08-10


437
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

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.

• a AND b: es true si a y b son true.


• a OR b: es true si a o b (o ambas) son true.
• NOT a: es true si a es false; es false si a es true.

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.

Precedencia en las condiciones


DynamoDB evalúa las condiciones de izquierda a derecha aplicando las siguientes normas de prioridad:

• = <> < <= > >=


• IN
• BETWEEN
• attribute_exists attribute_not_exists begins_with contains
• Paréntesis
• NOT
• AND
• OR

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.

UnaExpresión de actualizaciónespecifica cómoUpdateItemmodificará los atributos de un elemento; por


ejemplo, estableciendo un valor escalar o eliminando entradas de una lista o un mapa.

A continuación se muestra un resumen de la sintaxis de las expresiones de actualización.

update-expression ::=
[ SET action [, action] ... ]
[ REMOVE action [, action] ...]

Versión de API 2012-08-10


438
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

[ ADD action [, action] ... ]


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

SET: modificación o adición de atributos de elementos


Utilice la acción SET en una expresión de actualización para agregar uno o varios atributos a un elemento.
Si cualquiera de estos atributos ya existe, se sobrescribirá con los nuevos valores.

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.

En el resumen de sintaxis siguiente:

• El componente path es la ruta de documento del elemento.


• Un componente operand puede ser una ruta de documento a un elemento o una función.

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.

aws dynamodb put-item \


--table-name ProductCatalog \
--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": "789"},
"ProductCategory": {"S": "Home Improvement"},

Versión de API 2012-08-10


439
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

"Price": {"N": "52"},


"InStock": {"BOOL": true},
"Brand": {"S": "Acme"}
}

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.

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET ProductCategory = :c, Price = :p" \
--expression-attribute-values file://values.json \
--return-values ALL_NEW

Los argumentos de --expression-attribute-values se almacenan en el archivo values.json.

{
":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.

Adición de listas y mapas

Example
Agregue una lista y un mapa nuevos.

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET RelatedItems = :ri, ProductReviews = :pr" \
--expression-attribute-values file://values.json \
--return-values ALL_NEW

Los argumentos de --expression-attribute-values se almacenan en el archivo values.json.

{
":ri": {
"L": [

Versión de API 2012-08-10


440
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

{ "S": "Hammer" }
]
},
":pr": {
"M": {
"FiveStar": {
"L": [
{ "S": "Best product ever!" }
]
}
}
}
}

Adición de componentes a una lista

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.

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET RelatedItems[1] = :ri" \
--expression-attribute-values file://values.json \
--return-values ALL_NEW

Los argumentos de --expression-attribute-values se almacenan en el archivo values.json.

{
":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.

Adición de atributos de mapa anidados

Example
Agregue algunos atributos de mapa anidados.

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET #pr.#5star[1] = :r5, #pr.#3star = :r3" \
--expression-attribute-names file://names.json \
--expression-attribute-values file://values.json \
--return-values ALL_NEW

Los argumentos de --expression-attribute-names se almacenan en el archivo names.json.

{
"#pr": "ProductReviews",

Versión de API 2012-08-10


441
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

"#5star": "FiveStar",
"#3star": "ThreeStar"
}

Los argumentos de --expression-attribute-values se almacenan en el archivo values.json.

{
":r5": { "S": "Very happy with my purchase" },
":r3": {
"L": [
{ "S": "Just OK - not that great" }
]
}
}

Aumento y reducción de atributos numéricos


Puede sumar o restar un valor a un atributo numérico. Para ello, se utilizan los operadores + (más) y -
(menos).

Example
Reduzca el Price de un elemento.

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET Price = Price - :p" \
--expression-attribute-values '{":p": {"N":"15"}}' \
--return-values ALL_NEW

Para aumentar el valor de Price, se utiliza el operador + en la expresión de actualización.

Adición de componentes a una lista


Puede agregar componentes al final de una lista. Para ello, se utiliza SET con la función list_append. (El
nombre de la función distingue entre mayúsculas y minúsculas). La función list_append es específica
de la acción SET y solamente se puede utilizar en una expresión de actualización. La sintaxis es la
siguiente:

• list_append (list1, list2)

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.

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET #ri = list_append(#ri, :vals)" \
--expression-attribute-names '{"#ri": "RelatedItems"}' \
--expression-attribute-values file://values.json \
--return-values ALL_NEW

Los argumentos de --expression-attribute-values se almacenan en el archivo values.json.

Versión de API 2012-08-10


442
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

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

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET #ri = list_append(:vals, #ri)" \
--expression-attribute-names '{"#ri": "RelatedItems"}' \
--expression-attribute-values '{":vals": {"L": [ { "S": "Chisel" }]}}' \
--return-values ALL_NEW

Ahora, el atributo RelatedItems resultante contiene cinco entradas, el siguiente orden: Chisel, Hammer,
Nails, Screwdriver y Hacksaw.

Cómo evitar sobrescribir un atributo existente


Si desea evitar sobrescribir un atributo existente, puede utilizar SET con la función if_not_exists.
(El nombre de la función distingue entre mayúsculas y minúsculas). La función if_not_exists es
específica de la acción SET y solamente se puede utilizar en una expresión de actualización. La sintaxis es
la siguiente:

• if_not_exists (path, value)

Si el elemento no contiene un atributo en la ruta path especificada, if_not_exists se evalúa en value;


en caso contrario, se evalúa en path.

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

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET Price = if_not_exists(Price, :p)" \
--expression-attribute-values '{":p": {"N": "100"}}' \
--return-values ALL_NEW

REMOVE: eliminación de atributos de un elemento


UsarREMOVEEn una expresión de actualización para eliminar uno o varios atributos de un elemento en
Amazon DynamoDB. Para llevar a cabo varias acciones REMOVE, debe separarlas por comas.

A continuación se muestra un resumen de la sintaxis de REMOVE en una expresión de actualización. El


único operando es la ruta de documento del atributo que se desea eliminar.

remove-action ::=
path

Versión de API 2012-08-10


443
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

Example
Elimine algunos atributos de un elemento. (Si el atributo no existe, no sucede nada).

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "REMOVE Brand, InStock, QuantityOnHand" \
--return-values ALL_NEW

Eliminación de componentes de una lista


Puede utilizar REMOVE para eliminar entradas individuales de una lista.

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.

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "REMOVE RelatedItems[1], RelatedItems[2]" \
--return-values ALL_NEW

Después de eliminar Hammer y Nails, los componentes restantes se reordenan. Ahora, la lista contiene lo
siguiente:

• [0]—Chisel
• [1]—Screwdriver
• [2]—Hacksaw

ADD: actualización de números y conjuntos


Note
En general, recomendamos utilizar SET en lugar de ADD.

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.

Versión de API 2012-08-10


444
Amazon DynamoDB Guía para desarrolladores
Uso de expresiones

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.

En el resumen de sintaxis siguiente:

• 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

Supongamos que el atributo QuantityOnHand no existe. En el siguiente ejemplo de la AWS CLI,


QuantityOnHand se establece en 5.

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "ADD QuantityOnHand :q" \
--expression-attribute-values '{":q": {"N": "5"}}' \
--return-values ALL_NEW

Ahora que QuantityOnHand ya existe, puede volver a ejecutar el ejemplo para incrementar
QuantityOnHand en 5 cada vez.

Adición de componentes a un conjunto

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.

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "ADD Color :c" \
--expression-attribute-values '{":c": {"SS":["Orange", "Purple"]}}' \
--return-values ALL_NEW

Ahora que Color ya existe, podemos agregarle más componentes.

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "ADD Color :c" \
--expression-attribute-values '{":c": {"SS":["Yellow", "Green", "Blue"]}}' \
--return-values ALL_NEW

DELETE: eliminación de componentes de un conjunto


Important

La acción DELETE solo es compatible con tipos de datos Set.

Versión de API 2012-08-10


445
Amazon DynamoDB Guía para desarrolladores
Elementos que caducan con tiempo de vida

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.

En el resumen de sintaxis siguiente:

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

aws dynamodb update-item \


--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "DELETE Color :p" \
--expression-attribute-values '{":p": {"SS": ["Yellow", "Purple"]}}' \
--return-values ALL_NEW

Vencimiento de elementos mediante el uso de tiempo


de vida (TL) de DynamoDB
Tiempo de vida (TTL) de Amazon DynamoDB permite definir una marca temporal por elemento para
determinar cuándo ya no se necesita un elemento. Poco después de la fecha y hora de la marca temporal
especificada, DynamoDB elimina el elemento de la tabla sin consumir ningún rendimiento de escritura.
TTL se proporciona sin costo adicional como medio para reducir los volúmenes de datos almacenados
reteniendo solo los elementos que permanecen actualizados para las necesidades de su carga de trabajo.

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.

Para obtener más información acerca de TTL, consulte estos temas:

• Uso del Tiempo de vida.


• Tiempo de vida: Cómo funciona.
• Habilitación del tiempo de vida.

Funcionamiento: Tiempo de vida (TTTTTTTTT


Al habilitar TTL en una tabla de DynamoDB, debe identificar un nombre de atributo específico que el
servicio buscará al determinar si un elemento cumple los requisitos para el vencimiento. Después de

Versión de API 2012-08-10


446
Amazon DynamoDB Guía para desarrolladores
Elementos que caducan con tiempo de vida

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.

Versión de API 2012-08-10


447
Amazon DynamoDB Guía para desarrolladores
Elementos que caducan con tiempo de vida

Ejemplo de tiempo de vida


Por ejemplo, considere una tabla denominada SessionData que realiza el seguimiento del historial de
sesiones de los usuarios. Cada elemento en SessionData se identifica mediante la clave de partición
(UserName) y la clave de ordenación (SessionId). Otros atributos adicionales como UserName,
SessionId, CreationTime y ExpirationTime realizan el seguimiento de la información de la sesión.
El atributo ExpirationTime se establece como el atributo de TTL en la tabla (no se muestran todos los
atributos de cada elemento).

SessionData

UserName SessionId CreationTime ExpirationTime SessionInfo …


(TTL)

user1 74686572652773 1571820360 1571827560 {JSON ...


Document}

user2 6e6f7468696e67 1571820180 1571827380 {JSON ...


Document}

user3 746f2073656520 1571820923 1571828123 {JSON ...


Document}

user4 68657265212121 1571820683 1571827883 {JSON …


Document}

user5 6e6572642e2e2e 1571820743 1571831543 {JSON ...


Document}

... ... ... ... ... …

Versión de API 2012-08-10


448
Amazon DynamoDB Guía para desarrolladores
Elementos que caducan con tiempo de vida

En este ejemplo, cada elemento tiene un valor del atributo ExpirationTime que se establece al crearlo.
Considere el siguiente elemento de la tabla.

SessionData

UserName SessionId CreationTime ExpirationTime SessionInfo …


(TTL)

user1 74686572652773 1571820360 1571827560 {JSON ...


Document}

En este ejemplo, el elemento CreationTime se establece en miércoles 23 de octubre 08:46 h UTC de


2019 y ExpirationTime se establece 2 horas más tarde, miércoles 23 de octubre 10:46 h UTC de 2019.
El elemento vencerá cuando la fecha y hora actuales, en formato de tiempo Unix, sea mayor que la fecha
y hora del atributo ExpirationTime. En este caso, el elemento cuya clave es{ Username: user1,
SessionId: 74686572652773}caduca 10:46 AM (1571827560).

Uso de tiempo de vida (TL) de DynamoDB


Cuando se utiliza TTL, DynamoDB realiza la mayor parte del trabajo duro en segundo plano
automáticamente. Sin embargo, debe tener en cuenta algunas consideraciones para ayudar a su
implementación a avanzar sin problemas.

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)

Dar formato al atributo de TTL de un elemento


Al habilitar TTL en una tabla, DynamoDB requiere que identifique un nombre de atributo específico que
el servicio buscará al determinar si un elemento cumple los requisitos para el vencimiento. Además, otros
requisitos garantizan que los procesos de TTL en segundo plano utilicen el valor del atributo de TTL. Si un
elemento cumple los requisitos para el vencimiento a través de TTL:

• 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:

Versión de API 2012-08-10


449
Amazon DynamoDB Guía para desarrolladores
Elementos que caducan con tiempo de vida

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

Solución de problemas de TTL


Si TTL para DynamoDB no funciona, compruebe lo siguiente:

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

Habilitación del tiempo de vida (TTTTT


Puede usar la consola de Amazon DynamoDB o elAWS Command Line Interface(AWS CLI) para habilitar
Tiempo de vida. En su lugar, consulteReferencia de la API de Amazon DynamoDB.

Temas
• Habilitación del tiempo de vida (consola) (p. 450)
• Habilitación del tiempo de vida (AWS CLI) (p. 452)

Habilitación del tiempo de vida (consola)


Siga estos pasos para activar Tiempo de vida mediante la consola de DynamoDB:

1. Inicie sesión enAWS Management Consoley abra la consola de DynamoDB enhttps://


console.aws.amazon.com/dynamodb/.

Versión de API 2012-08-10


450
Amazon DynamoDB Guía para desarrolladores
Elementos que caducan con tiempo de vida

2. Elija Tables (Tablas) y, a continuación, seleccione la tabla que desee modificar.


3. En Table details (Detalles de tabla), junto a TTL attribute (Atributo TTL), elija Manage TTL (Administrar
TTL).

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

Hay tres valores en Manage TTL (Administrar 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).

Versión de API 2012-08-10


451
Amazon DynamoDB Guía para desarrolladores
Elementos que caducan con tiempo de vida

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.

Habilitación del tiempo de vida (AWS CLI)


1. Habilite TTL en la tabla TTLExample.

aws dynamodb update-time-to-live --table-name TTLExample --time-to-live-specification


"Enabled=true, AttributeName=ttl"

2. Describa TTL en la tabla TTLExample.

aws dynamodb describe-time-to-live --table-name TTLExample


{
"TimeToLiveDescription": {
"AttributeName": "ttl",
"TimeToLiveStatus": "ENABLED"
}
}

3. Agregue un elemento a la carpetaTTLExampleCon el atributo Tiempo de vida establecido mediante el


shell de BASH y elAWS CLI.

EXP=`date -d '+5 days' +%s`


aws dynamodb put-item --table-name "TTLExample" --item '{"id": {"N": "1"}, "ttl": {"N":
"'$EXP'"}}'

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

Versión de API 2012-08-10


452
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

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.

• Terminal Linux: date +%s


• Python: import time; int(time.time())
• Java: System.currentTimeMillis() / 1000L
• JavaScript: Math.floor(Date.now() / 1000)

Uso de elementos: Java


Puede utilizar la herramienta deAWS SDK for JavaDocument API para realizar operaciones típicas de
creación, lectura, actualización y eliminación (CRUD) en los elementos de Amazon DynamoDB en una
tabla.
Note

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

Sigue estos pasos:

1. Cree una instancia de la clase DynamoDB.


2. Cree una instancia de la clase Table para representar la tabla que desea usar.
3. Cree una instancia de la clase Item para representar el nuevo elemento. Debe especificar la clave
principal del nuevo elemento y sus atributos.

Versión de API 2012-08-10


453
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

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

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("ProductCatalog");

// Build a list of related items


List<Number> relatedItems = new ArrayList<Number>();
relatedItems.add(341);
relatedItems.add(472);
relatedItems.add(649);

//Build a map of product pictures


Map<String, String> pictures = new HashMap<String, String>();
pictures.put("FrontView", "http://example.com/products/123_front.jpg");
pictures.put("RearView", "http://example.com/products/123_rear.jpg");
pictures.put("SideView", "http://example.com/products/123_left_side.jpg");

//Build a map of product reviews


Map<String, List<String>> reviews = new HashMap<String, List<String>>();

List<String> fiveStarReviews = new ArrayList<String>();


fiveStarReviews.add("Excellent! Can't recommend it highly enough! Buy it!");
fiveStarReviews.add("Do yourself a favor and buy this");
reviews.put("FiveStar", fiveStarReviews);

List<String> oneStarReviews = new ArrayList<String>();


oneStarReviews.add("Terrible product! Do not buy this.");
reviews.put("OneStar", oneStarReviews);

// Build the item


Item item = new Item()
.withPrimaryKey("Id", 123)
.withString("Title", "Bicycle 123")
.withString("Description", "123 description")
.withString("BicycleType", "Hybrid")
.withString("Brand", "Brand-Company C")
.withNumber("Price", 500)
.withStringSet("Color", new HashSet<String>(Arrays.asList("Red", "Black")))
.withString("ProductCategory", "Bicycle")
.withBoolean("InStock", true)
.withNull("QuantityOnHand")
.withList("RelatedItems", relatedItems)
.withMap("Pictures", pictures)
.withMap("Reviews", reviews);

// Write the item to the table


PutItemOutcome outcome = table.putItem(item);

En el ejemplo anterior, el elemento tiene atributos que son escalares (String, Number, Boolean, Null),
conjuntos (String Set) y tipos de documentos (List, Map).

Especificación de parámetros opcionales


Junto con los parámetros requeridos, puede especificar también otros opcionales en el método putItem.
Por ejemplo, en el ejemplo de código Java siguiente se utiliza un parámetro opcional que permite

Versión de API 2012-08-10


454
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

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

Item item = new Item()


.withPrimaryKey("Id", 104)
.withString("Title", "Book 104 Title")
.withString("ISBN", "444-4444444444")
.withNumber("Price", 20)
.withStringSet("Authors",
new HashSet<String>(Arrays.asList("Author1", "Author2")));

Map<String, Object> expressionAttributeValues = new HashMap<String, Object>();


expressionAttributeValues.put(":val", "444-4444444444");

PutItemOutcome outcome = table.putItem(


item,
"ISBN = :val", // ConditionExpression parameter
null, // ExpressionAttributeNames parameter - we're not using it for this
example
expressionAttributeValues);

PutItem y documentos JSON


Puede almacenar un documento JSON como atributo en una tabla de DynamoDB. Para ello, se utiliza el
método withJSON de Item. Este método analiza el documento JSON y mapea cada componente a un
tipo de datos nativo de DynamoDB.

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

Versión de API 2012-08-10


455
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

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.

// Convert the document into a String. Must escape all double-quotes.


String vendorDocument = "{"
+ " \"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\""
+ " ]"
+ " }"
+ " }";

Item item = new Item()


.withPrimaryKey("Id", 210)
.withString("Title", "Book 210 Title")
.withString("ISBN", "210-2102102102")
.withNumber("Price", 30)
.withJSON("VendorInfo", vendorDocument);

PutItemOutcome outcome = table.putItem(item);

Obtención de un elemento
Para recuperar un solo elemento, utilice el método getItem de un objeto Table. Sigue estos pasos:

1. Cree una instancia de la clase DynamoDB.


2. Cree una instancia de la clase Table para representar la tabla que desea usar.
3. Llame al método getItem de la instancia de Table. Es preciso especificar la clave principal del
elemento que se desea recuperar.

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.

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("ProductCatalog");

Item item = table.getItem("Id", 210);

Especificación de parámetros opcionales


Junto con los parámetros requeridos, puede especificar también otros opcionales del método getItem.
Por ejemplo, en el siguiente ejemplo de código Java se utiliza un método opcional para recuperar solo una
lista concreta de atributos y especificar lecturas de consistencia alta. Para obtener más información sobre
la consistencia de lectura, consulte Consistencia de lectura (p. 17).

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

Versión de API 2012-08-10


456
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

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

GetItemSpec spec = new GetItemSpec()


.withPrimaryKey("Id", 206)
.withProjectionExpression("Id, Title, RelatedItems[0], Reviews.FiveStar")
.withConsistentRead(true);

Item item = table.getItem(spec);

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"
}

GetItem y documentos JSON


En la sección PutItem y documentos JSON (p. 455), almacena un documento JSON en un atributo
Map denominado VendorInfo. Puede utilizar el método getItem para recuperar todo el documento
en formato JSON. O puede usar la notación de ruta de documento para recuperar solo algunos de los
componentes de ese documento. En el siguiente ejemplo de código Java se muestran estas técnicas.

GetItemSpec spec = new GetItemSpec()


.withPrimaryKey("Id", 210);

System.out.println("All vendor info:");


spec.withProjectionExpression("VendorInfo");
System.out.println(table.getItem(spec).toJSON());

System.out.println("A single vendor:");


spec.withProjectionExpression("VendorInfo.V03");
System.out.println(table.getItem(spec).toJSON());

System.out.println("First office location for this vendor:");


spec.withProjectionExpression("VendorInfo.V03.Offices[0]");
System.out.println(table.getItem(spec).toJSON());

El resultado del ejemplo anterior tiene este aspecto.

All vendor info:


{"VendorInfo":{"V03":{"Name":"Better Buy Books","Offices":["Tokyo","Los
Angeles","Sydney"]},"V02":{"Name":"New Publishers, Inc.","Offices":["London","New
York"]},"V01":{"Name":"Acme Books","Offices":["Seattle"]}}}
A single vendor:

Versión de API 2012-08-10


457
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

{"VendorInfo":{"V03":{"Name":"Better Buy Books","Offices":["Tokyo","Los


Angeles","Sydney"]}}}
First office location for a single vendor:
{"VendorInfo":{"V03":{"Offices":["Tokyo"]}}}

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.

GetItemSpec spec = new GetItemSpec()


.withPrimaryKey("Id", 210)
.withProjectionExpression("VendorInfo.V01, Title, Price");

Item item = table.getItem(spec);


System.out.println(item.toJSON());

El resultado es similar al siguiente.

{"VendorInfo":{"V01":{"Name":"Acme Books","Offices":
["Seattle"]}},"Price":30,"Title":"Book 210 Title"}

Escritura Batch: Colocación y eliminación de varios elementos


La escritura por lotes se refiere a colocar y eliminar varios elementos en un lote. El método
batchWriteItem permite colocar y eliminar varios elementos de una o varias tablas con una sola
llamada. A continuación se indican los pasos para colocar o eliminar varios elementos mediante la API de
documentos del AWS SDK for Java.

1. Cree una instancia de la clase DynamoDB.


2. Cree una instancia de la clase TableWriteItems que describe todas las operaciones de colocación
y eliminación de una tabla. Si desea escribir en varias tablas en una misma operación de escritura por
lotes, debe crear una instancia de TableWriteItems por cada tabla.
3. Llame al método batchWriteItem proporcionando los objetos TableWriteItems que creó en el
paso anterior.
4. Procese la respuesta. Debe comprobar si en la respuesta se ha devuelto algún elemento de solicitud
sin procesar. Esto puede ocurrir si se alcanza la cuota de rendimiento aprovisionado o se produce
algún otro error transitorio. Además, DynamoDB limita el tamaño de la solicitud y el número de
operaciones que se pueden especificar en ella. Si supera estos límites, DynamoDB rechaza la
solicitud. Para obtener más información, consulte Cuotas de servicio, cuenta y tabla en Amazon
DynamoDB (p. 1066).

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:

• Colocar un elemento en la tabla Forum.


• Colocar y eliminar un elemento en la tabla Thread.

A continuación, el código llama a batchWriteItem para llevar a cabo la operación.

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB dynamoDB = new DynamoDB(client);

Versión de API 2012-08-10


458
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

TableWriteItems forumTableWriteItems = new TableWriteItems("Forum")


.withItemsToPut(
new Item()
.withPrimaryKey("Name", "Amazon RDS")
.withNumber("Threads", 0));

TableWriteItems threadTableWriteItems = new TableWriteItems("Thread")


.withItemsToPut(
new Item()
.withPrimaryKey("ForumName","Amazon RDS","Subject","Amazon RDS Thread 1")
.withHashAndRangeKeysToDelete("ForumName","Some partition key value", "Amazon S3",
"Some sort key value");

BatchWriteItemOutcome outcome = dynamoDB.batchWriteItem(forumTableWriteItems,


threadTableWriteItems);

// Code for checking unprocessed items is omitted in this example

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

Obtención Batch: Obtención de varios elementos


El método batchGetItem permite recuperar varios elementos de una o varias tablas. Para recuperar un
solo elemento, puede usar el método getItem.

Sigue estos pasos:

1. Cree una instancia de la clase DynamoDB.


2. Cree una instancia de la clase TableKeysAndAttributes que describe una lista de valores de
clave principal que se van a recuperar de una tabla. Si desea leer de varias tablas en una misma
operación de obtención por lotes, debe crear una instancia de TableKeysAndAttributes por cada
tabla.
3. Llame al método batchGetItem proporcionando los objetos TableKeysAndAttributes que creó
en el paso anterior.

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.

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB dynamoDB = new DynamoDB(client);

TableKeysAndAttributes forumTableKeysAndAttributes = new


TableKeysAndAttributes(forumTableName);
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys("Name",
"Amazon S3",
"Amazon DynamoDB");

TableKeysAndAttributes threadTableKeysAndAttributes = new


TableKeysAndAttributes(threadTableName);
threadTableKeysAndAttributes.addHashAndRangePrimaryKeys("ForumName", "Subject",
"Amazon DynamoDB","DynamoDB Thread 1",
"Amazon DynamoDB","DynamoDB Thread 2",
"Amazon S3","S3 Thread 1");

BatchGetItemOutcome outcome = dynamoDB.batchGetItem(


forumTableKeysAndAttributes, threadTableKeysAndAttributes);

for (String tableName : outcome.getTableItems().keySet()) {

Versión de API 2012-08-10


459
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

System.out.println("Items in table " + tableName);


List<Item> items = outcome.getTableItems().get(tableName);
for (Item item : items) {
System.out.println(item);
}
}

Especificación de parámetros opcionales


Junto con los parámetros requeridos, puede especificar también otros opcionales cuando use
batchGetItem. Por ejemplo, puede proporcionar una expresión ProjectionExpression con cada
TableKeysAndAttributes que defina. Esto le permite especificar los atributos que desea recuperar de
la tabla.

En el siguiente ejemplo de código se recuperan dos elementos de la tabla Forum. El parámetro


withProjectionExpression especifica que solamente hay que recuperar el atributo Threads.

Example

TableKeysAndAttributes forumTableKeysAndAttributes = new TableKeysAndAttributes("Forum")


.withProjectionExpression("Threads");

forumTableKeysAndAttributes.addHashOnlyPrimaryKeys("Name",
"Amazon S3",
"Amazon DynamoDB");

BatchGetItemOutcome outcome = dynamoDB.batchGetItem(forumTableKeysAndAttributes);

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.

El método updateItem se comporta de la siguiente manera:

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

Sigue estos pasos:

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.

Versión de API 2012-08-10


460
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

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.

Se utiliza un mapa ExpressionAttributeValues en UpdateExpression. Los marcadores de


posición :val1 y :val2 se sustituyen en tiempo de ejecución por los valores reales de Authors y
Price.

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("ProductCatalog");

Map<String, String> expressionAttributeNames = new HashMap<String, String>();


expressionAttributeNames.put("#A", "Authors");
expressionAttributeNames.put("#P", "Price");
expressionAttributeNames.put("#I", "ISBN");

Map<String, Object> expressionAttributeValues = new HashMap<String, Object>();


expressionAttributeValues.put(":val1",
new HashSet<String>(Arrays.asList("Author YY","Author ZZ")));
expressionAttributeValues.put(":val2", 1); //Price

UpdateItemOutcome outcome = table.updateItem(


"Id", // key attribute name
101, // key attribute value
"add #A :val1 set #P = #P - :val2 remove #I", // UpdateExpression
expressionAttributeNames,
expressionAttributeValues);

Especificación de parámetros opcionales


Junto con los parámetros requeridos, puede especificar también parámetros opcionales para el
método updateItem, incluida una condición que debe cumplirse para que se lleve a cabo la
actualización. Si la condición especificada no se cumple, AWS SDK for Java genera una excepción
ConditionalCheckFailedException. Por ejemplo, el siguiente ejemplo de código Java
actualiza de forma condicional el precio de un elemento de libro a 25. Especifica una expresión
ConditionExpression en la que se indica que el precio solo debe actualizarse si el precio actual es 20.

Example

Table table = dynamoDB.getTable("ProductCatalog");

Map<String, String> expressionAttributeNames = new HashMap<String, String>();


expressionAttributeNames.put("#P", "Price");

Map<String, Object> expressionAttributeValues = new HashMap<String, Object>();


expressionAttributeValues.put(":val1", 25); // update Price to 25...
expressionAttributeValues.put(":val2", 20); //...but only if existing Price is 20

UpdateItemOutcome outcome = table.updateItem(


new PrimaryKey("Id",101),
"set #P = :val1", // UpdateExpression
"#P = :val2", // ConditionExpression
expressionAttributeNames,
expressionAttributeValues);

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

Versión de API 2012-08-10


461
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

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.

En el siguiente ejemplo se pone en práctica lo anterior y se incrementa el atributo Quantity en una


unidad. También se demuestra cómo usar el parámetro ExpressionAttributeNames en una expresión
UpdateExpression.

Table table = dynamoDB.getTable("ProductCatalog");

Map<String,String> expressionAttributeNames = new HashMap<String,String>();


expressionAttributeNames.put("#p", "PageCount");

Map<String,Object> expressionAttributeValues = new HashMap<String,Object>();


expressionAttributeValues.put(":val", 1);

UpdateItemOutcome outcome = table.updateItem(


"Id", 121,
"set #p = #p + :val",
expressionAttributeNames,
expressionAttributeValues);

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.

Sigue estos pasos:

1. Cree una instancia del cliente de DynamoDB.


2. Llame al método deleteItem proporcionando la clave del elemento que desea eliminar.

En el siguiente ejemplo de Java se muestran estas tareas.

Example

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("ProductCatalog");

DeleteItemOutcome outcome = table.deleteItem("Id", 101);

Especificación de parámetros opcionales


Puede especificar parámetros opcionales para deleteItem. Por ejemplo, el siguiente ejemplo de
código Java incluye una expresión ConditionExpression que indica que un elemento de libro de
ProductCatalog solo se puede eliminar si el libro está descatalogado (el atributo InPublication es
false).

Example

Map<String,Object> expressionAttributeValues = new HashMap<String,Object>();


expressionAttributeValues.put(":val", false);

DeleteItemOutcome outcome = table.deleteItem("Id",103,


"InPublication = :val",

Versión de API 2012-08-10


462
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

null, // ExpressionAttributeNames - not used in this example


expressionAttributeValues);

Ejemplo: Operaciones CRUD mediante elAWS SDK for


JavaDocumentación de la API
En el siguiente ejemplo de código se ilustran las operaciones CRUD en un elemento de Amazon
DynamoDB. En el ejemplo se crea un elemento, se recupera, se llevan a cabo varias actualizaciones y, por
último, se elimina.
Note

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;

Versión de API 2012-08-10


463
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

public class DocumentAPIItemCRUDExample {

static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


static DynamoDB dynamoDB = new DynamoDB(client);

static String tableName = "ProductCatalog";

public static void main(String[] args) throws IOException {

createItems();

retrieveItem();

// Perform various updates.


updateMultipleAttributes();
updateAddNewAttribute();
updateExistingAttributeConditionally();

// Delete the item.


deleteItem();

private static void createItems() {

Table table = dynamoDB.getTable(tableName);


try {

Item item = new Item().withPrimaryKey("Id", 120).withString("Title", "Book 120


Title")
.withString("ISBN", "120-1111111111")
.withStringSet("Authors", new HashSet<String>(Arrays.asList("Author12",
"Author22")))
.withNumber("Price", 20).withString("Dimensions",
"8.5x11.0x.75").withNumber("PageCount", 500)
.withBoolean("InPublication", false).withString("ProductCategory", "Book");
table.putItem(item);

item = new Item().withPrimaryKey("Id", 121).withString("Title", "Book 121


Title")
.withString("ISBN", "121-1111111111")
.withStringSet("Authors", new HashSet<String>(Arrays.asList("Author21",
"Author 22")))
.withNumber("Price", 20).withString("Dimensions",
"8.5x11.0x.75").withNumber("PageCount", 500)
.withBoolean("InPublication", true).withString("ProductCategory", "Book");
table.putItem(item);

}
catch (Exception e) {
System.err.println("Create items failed.");
System.err.println(e.getMessage());

}
}

private static void retrieveItem() {


Table table = dynamoDB.getTable(tableName);

try {

Item item = table.getItem("Id", 120, "Id, ISBN, Title, Authors", null);

System.out.println("Printing item after retrieving it....");


System.out.println(item.toJSONPretty());

Versión de API 2012-08-10


464
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

}
catch (Exception e) {
System.err.println("GetItem failed.");
System.err.println(e.getMessage());
}

private static void updateAddNewAttribute() {


Table table = dynamoDB.getTable(tableName);

try {

UpdateItemSpec updateItemSpec = new UpdateItemSpec().withPrimaryKey("Id", 121)


.withUpdateExpression("set #na = :val1").withNameMap(new
NameMap().with("#na", "NewAttribute"))
.withValueMap(new ValueMap().withString(":val1", "Some
value")).withReturnValues(ReturnValue.ALL_NEW);

UpdateItemOutcome outcome = table.updateItem(updateItemSpec);

// Check the response.


System.out.println("Printing item after adding new attribute...");
System.out.println(outcome.getItem().toJSONPretty());

}
catch (Exception e) {
System.err.println("Failed to add new attribute in " + tableName);
System.err.println(e.getMessage());
}
}

private static void updateMultipleAttributes() {

Table table = dynamoDB.getTable(tableName);

try {

UpdateItemSpec updateItemSpec = new UpdateItemSpec().withPrimaryKey("Id", 120)


.withUpdateExpression("add #a :val1 set #na=:val2")
.withNameMap(new NameMap().with("#a", "Authors").with("#na",
"NewAttribute"))
.withValueMap(
new ValueMap().withStringSet(":val1", "Author YY", "Author
ZZ").withString(":val2", "someValue"))
.withReturnValues(ReturnValue.ALL_NEW);

UpdateItemOutcome outcome = table.updateItem(updateItemSpec);

// Check the response.


System.out.println("Printing item after multiple attribute update...");
System.out.println(outcome.getItem().toJSONPretty());

}
catch (Exception e) {
System.err.println("Failed to update multiple attributes in " + tableName);
System.err.println(e.getMessage());

}
}

private static void updateExistingAttributeConditionally() {

Table table = dynamoDB.getTable(tableName);

try {

Versión de API 2012-08-10


465
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

// Specify the desired price (25.00) and also the condition (price =
// 20.00)

UpdateItemSpec updateItemSpec = new UpdateItemSpec().withPrimaryKey("Id", 120)


.withReturnValues(ReturnValue.ALL_NEW).withUpdateExpression("set #p
= :val1")
.withConditionExpression("#p = :val2").withNameMap(new NameMap().with("#p",
"Price"))
.withValueMap(new ValueMap().withNumber(":val1", 25).withNumber(":val2",
20));

UpdateItemOutcome outcome = table.updateItem(updateItemSpec);

// Check the response.


System.out.println("Printing item after conditional update to new
attribute...");
System.out.println(outcome.getItem().toJSONPretty());

}
catch (Exception e) {
System.err.println("Error updating item in " + tableName);
System.err.println(e.getMessage());
}
}

private static void deleteItem() {

Table table = dynamoDB.getTable(tableName);

try {

DeleteItemSpec deleteItemSpec = new DeleteItemSpec().withPrimaryKey("Id", 120)


.withConditionExpression("#ip = :val").withNameMap(new
NameMap().with("#ip", "InPublication"))
.withValueMap(new ValueMap().withBoolean(":val",
false)).withReturnValues(ReturnValue.ALL_OLD);

DeleteItemOutcome outcome = table.deleteItem(deleteItemSpec);

// Check the response.


System.out.println("Printing item that was deleted...");
System.out.println(outcome.getItem().toJSONPretty());

}
catch (Exception e) {
System.err.println("Error deleting item in " + tableName);
System.err.println(e.getMessage());
}
}
}

Ejemplo: Uso de operaciones por lotes medianteAWS SDK for


JavaDocumentación de la API
En esta sección se proporcionan ejemplos de operaciones de escritura y obtención por lotes en Amazon
DynamoDB mediante elAWS SDK for JavaDocumentación de la API
Note

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

Versión de API 2012-08-10


466
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

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)

Ejemplo: Operación de escritura por lotes mediante elAWS SDK for


JavaDocumentación de la API
En el siguiente ejemplo de código Java se usa el método batchWriteItem para llevar a cabo las
siguientes operaciones de colocación y eliminación:

• Colocar un elemento en la tabla Forum.


• Colocar un elemento y eliminar un elemento de la tabla Thread.

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;

Versión de API 2012-08-10


467
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

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;

public class DocumentAPIBatchWrite {

static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


static DynamoDB dynamoDB = new DynamoDB(client);

static String forumTableName = "Forum";


static String threadTableName = "Thread";

public static void main(String[] args) throws IOException {

writeMultipleItemsBatchWrite();

private static void writeMultipleItemsBatchWrite() {


try {

// Add a new item to Forum


TableWriteItems forumTableWriteItems = new TableWriteItems(forumTableName) //
Forum
.withItemsToPut(new Item().withPrimaryKey("Name", "Amazon
RDS").withNumber("Threads", 0));

// Add a new item, and delete an existing item, from Thread


// This table has a partition key and range key, so need to specify
// both of them
TableWriteItems threadTableWriteItems = new TableWriteItems(threadTableName)
.withItemsToPut(new Item().withPrimaryKey("ForumName", "Amazon RDS",
"Subject", "Amazon RDS Thread 1")
.withString("Message", "ElastiCache Thread 1 message")
.withStringSet("Tags", new HashSet<String>(Arrays.asList("cache", "in-
memory"))))
.withHashAndRangeKeysToDelete("ForumName", "Subject", "Amazon S3", "S3
Thread 100");

System.out.println("Making the request.");


BatchWriteItemOutcome outcome = dynamoDB.batchWriteItem(forumTableWriteItems,
threadTableWriteItems);

do {

// Check for unprocessed keys which could happen if you exceed


// provisioned throughput

Map<String, List<WriteRequest>> unprocessedItems =


outcome.getUnprocessedItems();

if (outcome.getUnprocessedItems().size() == 0) {
System.out.println("No unprocessed items found");
}
else {
System.out.println("Retrieving the unprocessed items");
outcome = dynamoDB.batchWriteItemUnprocessed(unprocessedItems);
}

} while (outcome.getUnprocessedItems().size() > 0);

Versión de API 2012-08-10


468
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

}
catch (Exception e) {
System.err.println("Failed to retrieve items: ");
e.printStackTrace(System.err);
}

Ejemplo: Operación de obtención por lotes mediante elAWS SDK for


JavaDocumentación de la API
En el siguiente ejemplo de código Java se usa el método batchGetItem para recuperar varios elementos
de las tablas Forum y Thread. La solicitud BatchGetItemRequest especifica los nombres de las tablas
y una lista de claves para cada elemento que se desea obtener. En el ejemplo se procesa la respuesta y
se imprimen los elementos recuperados.
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.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;

public class DocumentAPIBatchGet {


static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
static DynamoDB dynamoDB = new DynamoDB(client);

Versión de API 2012-08-10


469
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

static String forumTableName = "Forum";


static String threadTableName = "Thread";

public static void main(String[] args) throws IOException {


retrieveMultipleItemsBatchGet();
}

private static void retrieveMultipleItemsBatchGet() {

try {

TableKeysAndAttributes forumTableKeysAndAttributes = new


TableKeysAndAttributes(forumTableName);
// Add a partition key
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys("Name", "Amazon S3", "Amazon
DynamoDB");

TableKeysAndAttributes threadTableKeysAndAttributes = new


TableKeysAndAttributes(threadTableName);
// Add a partition key and a sort key
threadTableKeysAndAttributes.addHashAndRangePrimaryKeys("ForumName", "Subject",
"Amazon DynamoDB",
"DynamoDB Thread 1", "Amazon DynamoDB", "DynamoDB Thread 2", "Amazon S3",
"S3 Thread 1");

System.out.println("Making the request.");

BatchGetItemOutcome outcome =
dynamoDB.batchGetItem(forumTableKeysAndAttributes,
threadTableKeysAndAttributes);

Map<String, KeysAndAttributes> unprocessed = null;

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

// Check for unprocessed keys which could happen if you exceed


// provisioned
// throughput or reach the limit on response size.
unprocessed = outcome.getUnprocessedKeys();

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

Versión de API 2012-08-10


470
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

Ejemplo: Control de atributos de tipo Binary mediante elAWS


SDK for JavaDocumentación de la API
En el siguiente ejemplo se ilustra cómo se controlan los atributos de tipo Binary. Además, se agrega
un elemento a la tabla Reply. El elemento incluye un atributo de tipo Binary (ExtendedMessage) que
almacena datos comprimidos. A continuación, en el ejemplo se recupera el elemento y se imprimen todos
los valores de los atributos. Con fines ilustrativos, el ejemplo usa la clase GZIPOutputStream para
comprimir un ejemplo de secuencia y asignársela al atributo ExtendedMessage. Cuando se recupera el
atributo binario, se descomprime mediante la clase GZIPInputStream.
Note

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

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 la tabla Reply. También puede crear esta tabla
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.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;

Versión de API 2012-08-10


471
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.GetItemSpec;

public class DocumentAPIItemBinaryExample {

static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


static DynamoDB dynamoDB = new DynamoDB(client);

static String tableName = "Reply";


static SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-
dd'T'HH:mm:ss.SSS'Z'");

public static void main(String[] args) throws IOException {


try {

// Format the primary key values


String threadId = "Amazon DynamoDB#DynamoDB Thread 2";

dateFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
String replyDateTime = dateFormatter.format(new Date());

// Add a new reply with a binary attribute type


createItem(threadId, replyDateTime);

// Retrieve the reply with a binary attribute type


retrieveItem(threadId, replyDateTime);

// clean up by deleting the item


deleteItem(threadId, replyDateTime);
}
catch (Exception e) {
System.err.println("Error running the binary attribute type example: " + e);
e.printStackTrace(System.err);
}
}

public static void createItem(String threadId, String replyDateTime) throws IOException


{

Table table = dynamoDB.getTable(tableName);

// Craft a long message


String messageInput = "Long message to be compressed in a lengthy forum reply";

// Compress the long message


ByteBuffer compressedMessage = compressString(messageInput.toString());

table.putItem(new Item().withPrimaryKey("Id", threadId).withString("ReplyDateTime",


replyDateTime)
.withString("Message", "Long message follows").withBinary("ExtendedMessage",
compressedMessage)
.withString("PostedBy", "User A"));
}

public static void retrieveItem(String threadId, String replyDateTime) throws


IOException {

Table table = dynamoDB.getTable(tableName);

GetItemSpec spec = new GetItemSpec().withPrimaryKey("Id", threadId,


"ReplyDateTime", replyDateTime)
.withConsistentRead(true);

Item item = table.getItem(spec);

Versión de API 2012-08-10


472
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: Java

// Uncompress the reply message and print


String uncompressed =
uncompressString(ByteBuffer.wrap(item.getBinary("ExtendedMessage")));

System.out.println("Reply message:\n" + " Id: " + item.getString("Id") + "\n" + "


ReplyDateTime: "
+ item.getString("ReplyDateTime") + "\n" + " PostedBy: " +
item.getString("PostedBy") + "\n" + " Message: "
+ item.getString("Message") + "\n" + " ExtendedMessage (uncompressed): " +
uncompressed + "\n");
}

public static void deleteItem(String threadId, String replyDateTime) {

Table table = dynamoDB.getTable(tableName);


table.deleteItem("Id", threadId, "ReplyDateTime", replyDateTime);
}

private static ByteBuffer compressString(String input) throws IOException {


// Compress the UTF-8 encoded String into a byte[]
ByteArrayOutputStream baos = new ByteArrayOutputStream();
GZIPOutputStream os = new GZIPOutputStream(baos);
os.write(input.getBytes("UTF-8"));
os.close();
baos.close();
byte[] compressedBytes = baos.toByteArray();

// The following code writes the compressed bytes to a ByteBuffer.


// A simpler way to do this is by simply calling
// ByteBuffer.wrap(compressedBytes);
// However, the longer form below shows the importance of resetting the
// position of the buffer
// back to the beginning of the buffer if you are writing bytes directly
// to it, since the SDK
// will consider only the bytes after the current position when sending
// data to DynamoDB.
// Using the "wrap" method automatically resets the position to zero.
ByteBuffer buffer = ByteBuffer.allocate(compressedBytes.length);
buffer.put(compressedBytes, 0, compressedBytes.length);
buffer.position(0); // Important: reset the position of the ByteBuffer
// to the beginning
return buffer;
}

private static String uncompressString(ByteBuffer input) throws IOException {


byte[] bytes = input.array();
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
GZIPInputStream is = new GZIPInputStream(bais);

int chunkSize = 1024;


byte[] buffer = new byte[chunkSize];
int length = 0;
while ((length = is.read(buffer, 0, chunkSize)) != -1) {
baos.write(buffer, 0, length);
}

String result = new String(baos.toByteArray(), "UTF-8");

is.close();
baos.close();
bais.close();

return result;
}
}

Versión de API 2012-08-10


473
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

Uso de elementos: .NET


Puede utilizar la herramienta deAWS SDK for .NETAPI de bajo nivel para realizar operaciones típicas de
creación, lectura, actualización y eliminación (CRUD, Create, Read, Update and Delete) en los elementos
de una tabla. A continuación se indican los pasos que suelen llevarse a cabo para realizar operaciones
CRUD mediante el API de bajo nivel de .NET:

1. Cree una instancia de la clase AmazonDynamoDBClient (el cliente).


2. Proporcione los parámetros requeridos específicos de la operación en el objeto de solicitud
correspondiente.

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.

El cliente AmazonDynamoDBClient proporciona los métodos PutItem, GetItem, UpdateItem y


DeleteItem para las operaciones CRUD.

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:

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree una instancia de la clase PutItemRequest para proporcionar los parámetros requeridos.

Para colocar un elemento, debe proporcionar el nombre de la tabla y el elemento.

Versión de API 2012-08-10


474
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

3. Ejecute laPutItemal proporcionar el métodoPutItemRequestObjeto que creó en el paso anterior.

En el siguiente ejemplo de C# se ponen en práctica los pasos anteriores. En el ejemplo se carga un


elemento en la tabla ProductCatalog.

Example

AmazonDynamoDBClient client = new AmazonDynamoDBClient();


string tableName = "ProductCatalog";

var request = new PutItemRequest


{
TableName = tableName,
Item = new Dictionary<string, AttributeValue>()
{
{ "Id", new AttributeValue { N = "201" }},
{ "Title", new AttributeValue { S = "Book 201 Title" }},
{ "ISBN", new AttributeValue { S = "11-11-11-11" }},
{ "Price", new AttributeValue { S = "20.00" }},
{
"Authors",
new AttributeValue
{ SS = new List<string>{"Author1", "Author2"} }
}
}
};
client.PutItem(request);

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.

Especificación de parámetros opcionales


También puede usar la opción de proporcionar parámetros opcionales mediante elPutItemRequestComo
se muestra en el ejemplo de C# siguiente. En el ejemplo se especifican los parámetros opcionales
siguientes:

• ExpressionAttributeNames, ExpressionAttributeValues y ConditionExpression


especifican que el elemento existente se puede sustituir únicamente si su atributo ISBN tiene un valor
específico.
• El parámetro ReturnValues para solicitar el elemento anterior en la respuesta.

Example

var request = new PutItemRequest


{
TableName = tableName,
Item = new Dictionary<string, AttributeValue>()
{
{ "Id", new AttributeValue { N = "104" }},
{ "Title", new AttributeValue { S = "Book 104 Title" }},
{ "ISBN", new AttributeValue { S = "444-4444444444" }},
{ "Authors",
new AttributeValue { SS = new List<string>{"Author3"}}}
},
// Optional parameters.
ExpressionAttributeNames = new Dictionary<string,string>()
{

Versión de API 2012-08-10


475
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

{"#I", "ISBN"}
},
ExpressionAttributeValues = new Dictionary<string, AttributeValue>()
{
{":isbn",new AttributeValue {S = "444-4444444444"}}
},
ConditionExpression = "#I = :isbn"

};
var response = client.PutItem(request);

Para obtener más información, consulte PutItem.

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.

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree una instancia de la clase GetItemRequest para proporcionar los parámetros requeridos.

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.

En el siguiente ejemplo de C# se ponen en práctica los pasos anteriores. En el ejemplo se recupera un


elemento de laProductCatalogTabla INTO

AmazonDynamoDBClient client = new AmazonDynamoDBClient();


string tableName = "ProductCatalog";

var request = new GetItemRequest


{
TableName = tableName,
Key = new Dictionary<string,AttributeValue>() { { "Id", new AttributeValue { N =
"202" } } },
};
var response = client.GetItem(request);

// Check the response.


var result = response.GetItemResult;
var attributeMap = result.Item; // Attribute list in the response.

Especificación de parámetros opcionales


También puede usar la opción de proporcionar parámetros opcionales mediante
elGetItemRequestObjeto, tal y como se muestra en el ejemplo de C# siguiente. En el ejemplo se
especifican los parámetros opcionales siguientes:

• El parámetro ProjectionExpression para especificar los atributos que se van a recuperar.


• ConsistentReadEl parámetro para realizar una lectura de consistencia alta. Para obtener más
información sobre la consistencia de lectura, consulte Consistencia de lectura (p. 17).

Versión de API 2012-08-10


476
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

Example

AmazonDynamoDBClient client = new AmazonDynamoDBClient();


string tableName = "ProductCatalog";

var request = new GetItemRequest


{
TableName = tableName,
Key = new Dictionary<string,AttributeValue>() { { "Id", new AttributeValue { N =
"202" } } },
// Optional parameters.
ProjectionExpression = "Id, ISBN, Title, Authors",
ConsistentRead = true
};

var response = client.GetItem(request);

// Check the response.


var result = response.GetItemResult;
var attributeMap = result.Item;

Para obtener más información, consulteGetItem.

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.

La operación UpdateItem se rige por las directrices siguientes:

• Si el elemento no existe, UpdateItem agrega un elemento nuevo utilizando la clave principal


especificada en la información de entrada.
• Si el elemento existe, UpdateItem aplica las actualizaciones como se indica a continuación:
• Sustituye los valores de los atributos existentes por los valores de la actualización.
• Si el atributo que se proporciona en la información de entrada no existe, agrega un nuevo atributo al
elemento.
• Si el atributo de entrada es null, elimina el atributo, en caso de que esté presente.
• Si usaADDpara laAction, puede agregar valores a un conjunto existente (de tipo String Set o
Number Set) o bien sumar (si se usa un número positivo) o restar (si se usa un número negativo)
matemáticamente un valor del atributo numérico existente.

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:

1. Cree una instancia de la clase AmazonDynamoDBClient.

Versión de API 2012-08-10


477
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .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.

AmazonDynamoDBClient client = new AmazonDynamoDBClient();


string tableName = "ProductCatalog";

var request = new UpdateItemRequest


{
TableName = tableName,
Key = new Dictionary<string,AttributeValue>() { { "Id", new AttributeValue { N =
"202" } } },
ExpressionAttributeNames = new Dictionary<string,string>()
{
{"#A", "Authors"},
{"#P", "Price"},
{"#NA", "NewAttribute"},
{"#I", "ISBN"}
},
ExpressionAttributeValues = new Dictionary<string, AttributeValue>()
{
{":auth",new AttributeValue { SS = {"Author YY","Author ZZ"}}},
{":p",new AttributeValue {N = "1"}},
{":newattr",new AttributeValue {S = "someValue"}},
},

// This expression does the following:


// 1) Adds two new authors to the list
// 2) Reduces the price
// 3) Adds a new attribute to the item
// 4) Removes the ISBN attribute from the item
UpdateExpression = "ADD #A :auth SET #P = #P - :p, #NA = :newattr REMOVE #I"
};
var response = client.UpdateItem(request);

Especificación de parámetros opcionales


También puede usar la opción de proporcionar parámetros opcionales mediante
elUpdateItemRequestObjeto, tal y como se muestra en el ejemplo de C# siguiente. En él se especifican
los parámetros opcionales siguientes:

• ExpressionAttributeValues y ConditionExpression para especificar que el precio solo puede


actualizarse si el precio actual es 20.00.
• El parámetro ReturnValues para solicitar el elemento actualizado en la respuesta.

Example

AmazonDynamoDBClient client = new AmazonDynamoDBClient();


string tableName = "ProductCatalog";

Versión de API 2012-08-10


478
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

var request = new UpdateItemRequest


{
Key = new Dictionary<string,AttributeValue>() { { "Id", new AttributeValue { N =
"202" } } },

// Update price only if the current price is 20.00.


ExpressionAttributeNames = new Dictionary<string,string>()
{
{"#P", "Price"}
},
ExpressionAttributeValues = new Dictionary<string, AttributeValue>()
{
{":newprice",new AttributeValue {N = "22"}},
{":currprice",new AttributeValue {N = "20"}}
},
UpdateExpression = "SET #P = :newprice",
ConditionExpression = "#P = :currprice",
TableName = tableName,
ReturnValues = "ALL_NEW" // Return all the attributes of the updated item.
};

var response = client.UpdateItem(request);

Para obtener más información, consulte UpdateItem.

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.

En el siguiente ejemplo se pone en práctica lo anterior y se incrementa el atributo Quantity en una


unidad.

AmazonDynamoDBClient client = new AmazonDynamoDBClient();


string tableName = "ProductCatalog";

var request = new UpdateItemRequest


{
Key = new Dictionary<string, AttributeValue>() { { "Id", new AttributeValue { N =
"121" } } },
ExpressionAttributeNames = new Dictionary<string, string>()
{
{"#Q", "Quantity"}
},
ExpressionAttributeValues = new Dictionary<string, AttributeValue>()
{
{":incr",new AttributeValue {N = "1"}}
},
UpdateExpression = "SET #Q = #Q + :incr",
TableName = tableName
};

var response = client.UpdateItem(request);

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.

Versión de API 2012-08-10


479
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree una instancia de la clase DeleteItemRequest para proporcionar los parámetros requeridos.

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

AmazonDynamoDBClient client = new AmazonDynamoDBClient();


string tableName = "ProductCatalog";

var request = new DeleteItemRequest


{
TableName = tableName,
Key = new Dictionary<string,AttributeValue>() { { "Id", new AttributeValue { N =
"201" } } },
};

var response = client.DeleteItem(request);

Especificación de parámetros opcionales


También puede usar la opción de proporcionar parámetros opcionales mediante
elDeleteItemRequestComo se muestra en el siguiente ejemplo de código C#. En él se especifican los
parámetros opcionales siguientes:

• ExpressionAttributeValues y ConditionExpression para especificar que el elemento de libro


solo se puede eliminar si está descatalogado (el valor del atributo InPublication es false).
• El parámetro ReturnValues para solicitar el elemento eliminado en la respuesta.

Example

var request = new DeleteItemRequest


{
TableName = tableName,
Key = new Dictionary<string,AttributeValue>() { { "Id", new AttributeValue { N =
"201" } } },

// 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"
};

var response = client.DeleteItem(request);

Para obtener más información, consulteDeleteItem.

Versión de API 2012-08-10


480
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

Escritura Batch: Colocación y eliminación de varios elementos


La escritura por lotes se refiere a colocar y eliminar varios elementos en un lote. El método
BatchWriteItem permite colocar y eliminar varios elementos de una o varias tablas con una sola
llamada. A continuación se indican los pasos que hay que seguir para recuperar varios elementos
mediante el API de bajo nivel del SDK para .NET.

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree una instancia de la clase BatchWriteItemRequest para describir todas las operaciones de
colocación y eliminación.
3. Ejecute laBatchWriteItemal proporcionar el métodoBatchWriteItemRequestObjeto que creó en
el paso anterior.
4. Procese la respuesta. Debe comprobar si en la respuesta se ha devuelto algún elemento de solicitud
sin procesar. Esto puede ocurrir si se alcanza la cuota de rendimiento aprovisionado o se produce
algún otro error transitorio. Además, DynamoDB limita el tamaño de la solicitud y el número de
operaciones que se pueden especificar en ella. Si supera estos límites, DynamoDB rechaza la
solicitud. Para obtener más información, consulteBatchWriteItem.

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:

• Colocar un elemento enForumTabla INTO


• Colocar y eliminar un elemento deThreadTabla INTO

Ejecuta el códigoBatchWriteItemPara realizar una operación por lotes.

AmazonDynamoDBClient client = new AmazonDynamoDBClient();

string table1Name = "Forum";


string table2Name = "Thread";

var request = new BatchWriteItemRequest


{
RequestItems = new Dictionary<string, List<WriteRequest>>
{
{
table1Name, new List<WriteRequest>
{
new WriteRequest
{
PutRequest = new PutRequest
{
Item = new Dictionary<string,AttributeValue>
{
{ "Name", new AttributeValue { S = "Amazon S3 forum" } },
{ "Threads", new AttributeValue { N = "0" }}
}
}
}
}
} ,
{
table2Name, new List<WriteRequest>
{
new WriteRequest
{
PutRequest = new PutRequest
{
Item = new Dictionary<string,AttributeValue>

Versión de API 2012-08-10


481
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

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

Obtención Batch: Obtención de varios elementos


El método BatchGetItem permite recuperar varios elementos de una o varias tablas.
Note

Para recuperar un solo elemento, puede usar el método GetItem.

A continuación se indican los pasos que hay que seguir para recuperar varios elementos mediante elAWS
SDK for .NETAPI.

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree una instancia de la clase BatchGetItemRequest para proporcionar los parámetros requeridos.

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.

En el siguiente ejemplo de código C# se ponen en práctica los pasos anteriores. En el ejemplo se


recuperan elementos de dos tablas,ForumyThread. La solicitud especifica dos elementos en elForumy
tres elementos en elThreadTabla INTO La respuesta incluye elementos de ambas tablas. En el código se
muestra cómo procesar la respuesta.

AmazonDynamoDBClient client = new AmazonDynamoDBClient();

string table1Name = "Forum";


string table2Name = "Thread";

Versión de API 2012-08-10


482
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

var request = new BatchGetItemRequest


{
RequestItems = new Dictionary<string, KeysAndAttributes>()
{
{ table1Name,
new KeysAndAttributes
{
Keys = new List<Dictionary<string, AttributeValue>>()
{
new Dictionary<string, AttributeValue>()
{
{ "Name", new AttributeValue { S = "DynamoDB" } }
},
new Dictionary<string, AttributeValue>()
{
{ "Name", new AttributeValue { S = "Amazon S3" } }
}
}
}
},
{
table2Name,
new KeysAndAttributes
{
Keys = new List<Dictionary<string, AttributeValue>>()
{
new Dictionary<string, AttributeValue>()
{
{ "ForumName", new AttributeValue { S = "DynamoDB" } },
{ "Subject", new AttributeValue { S = "DynamoDB Thread 1" } }
},
new Dictionary<string, AttributeValue>()
{
{ "ForumName", new AttributeValue { S = "DynamoDB" } },
{ "Subject", new AttributeValue { S = "DynamoDB Thread 2" } }
},
new Dictionary<string, AttributeValue>()
{
{ "ForumName", new AttributeValue { S = "Amazon S3" } },
{ "Subject", new AttributeValue { S = "Amazon S3 Thread 1" } }
}
}
}
}
}
};

var response = client.BatchGetItem(request);

// Check the response.


var result = response.BatchGetItemResult;
var responses = result.Responses; // The attribute list in the response.

var table1Results = responses[table1Name];


Console.WriteLine("Items in table {0}" + table1Name);
foreach (var item1 in table1Results.Items)
{
PrintItem(item1);
}

var table2Results = responses[table2Name];


Console.WriteLine("Items in table {1}" + table2Name);
foreach (var item2 in table2Results.Items)
{
PrintItem(item2);

Versión de API 2012-08-10


483
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

}
// 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);
}

Especificación de parámetros opcionales


También puede usar la opción de proporcionar parámetros opcionales mediante
elBatchGetItemRequestComo se muestra en el siguiente ejemplo de código C#. En el ejemplo se
recuperan dos elementos de laForumTabla INTO En él se especifica el parámetro opcional siguiente:

• El parámetro ProjectionExpression para especificar los atributos que se van a recuperar.

Example

AmazonDynamoDBClient client = new AmazonDynamoDBClient();

string table1Name = "Forum";

var request = new BatchGetItemRequest


{
RequestItems = new Dictionary<string, KeysAndAttributes>()
{
{ table1Name,
new KeysAndAttributes
{
Keys = new List<Dictionary<string, AttributeValue>>()
{
new Dictionary<string, AttributeValue>()
{
{ "Name", new AttributeValue { S = "DynamoDB" } }
},
new Dictionary<string, AttributeValue>()
{
{ "Name", new AttributeValue { S = "Amazon S3" } }
}
}
},
// Optional - name of an attribute to retrieve.
ProjectionExpression = "Title"
}
}
};

var response = client.BatchGetItem(request);

Para obtener más información, consulteBatchGetItem.

Ejemplo: Operaciones CRUD mediante elAWS SDK for .NETAPI


de bajo nivel
En el siguiente ejemplo de código C# se ilustran las operaciones CRUD en un elemento de Amazon
DynamoDB. En el ejemplo se agrega un elemento alProductCatalog, la recupera, lleva a cabo varias
actualizaciones y, por último, elimina. Si ha seguido los pasos deCreación de tablas y carga de datos para
ejemplos de código en DynamoDB (p. 333), ya tiene elProductCatalogCreada. También puede crear

Versión de API 2012-08-10


484
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

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

static void Main(string[] args)


{
try
{
CreateItem();
RetrieveItem();

// Perform various updates.


UpdateMultipleAttributes();
UpdateExistingAttributeConditionally();

// 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();
}
}

private static void CreateItem()


{
var request = new PutItemRequest
{
TableName = tableName,

Versión de API 2012-08-10


485
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

Item = new Dictionary<string, AttributeValue>()


{
{ "Id", new AttributeValue {
N = "1000"
}},
{ "Title", new AttributeValue {
S = "Book 201 Title"
}},
{ "ISBN", new AttributeValue {
S = "11-11-11-11"
}},
{ "Authors", new AttributeValue {
SS = new List<string>{"Author1", "Author2" }
}},
{ "Price", new AttributeValue {
N = "20.00"
}},
{ "Dimensions", new AttributeValue {
S = "8.5x11.0x.75"
}},
{ "InPublication", new AttributeValue {
BOOL = false
} }
}
};
client.PutItem(request);
}

private static void RetrieveItem()


{
var request = new GetItemRequest
{
TableName = tableName,
Key = new Dictionary<string, AttributeValue>()
{
{ "Id", new AttributeValue {
N = "1000"
} }
},
ProjectionExpression = "Id, ISBN, Title, Authors",
ConsistentRead = true
};
var response = client.GetItem(request);

// Check the response.


var attributeList = response.Item; // attribute list in the response.
Console.WriteLine("\nPrinting item after retrieving it ............");
PrintItem(attributeList);
}

private static void UpdateMultipleAttributes()


{
var request = new UpdateItemRequest
{
Key = new Dictionary<string, AttributeValue>()
{
{ "Id", new AttributeValue {
N = "1000"
} }
},
// Perform the following updates:
// 1) Add two new authors to the list
// 1) Set a new attribute
// 2) Remove the ISBN attribute
ExpressionAttributeNames = new Dictionary<string, string>()
{

Versión de API 2012-08-10


486
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

{"#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"
}}
},

UpdateExpression = "ADD #A :auth SET #NA = :new REMOVE #I",

TableName = tableName,
ReturnValues = "ALL_NEW" // Give me all attributes of the updated item.
};
var response = client.UpdateItem(request);

// Check the response.


var attributeList = response.Attributes; // attribute list in the response.
// print attributeList.
Console.WriteLine("\nPrinting item after multiple attribute
update ............");
PrintItem(attributeList);
}

private static void UpdateExistingAttributeConditionally()


{
var request = new UpdateItemRequest
{
Key = new Dictionary<string, AttributeValue>()
{
{ "Id", new AttributeValue {
N = "1000"
} }
},
ExpressionAttributeNames = new Dictionary<string, string>()
{
{"#P", "Price"}
},
ExpressionAttributeValues = new Dictionary<string, AttributeValue>()
{
{":newprice",new AttributeValue {
N = "22.00"
}},
{":currprice",new AttributeValue {
N = "20.00"
}}
},
// This updates price only if current price is 20.00.
UpdateExpression = "SET #P = :newprice",
ConditionExpression = "#P = :currprice",

TableName = tableName,
ReturnValues = "ALL_NEW" // Give me all attributes of the updated item.
};
var response = client.UpdateItem(request);

// Check the response.


var attributeList = response.Attributes; // attribute list in the response.
Console.WriteLine("\nPrinting item after updating price value
conditionally ............");
PrintItem(attributeList);

Versión de API 2012-08-10


487
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

private static void DeleteItem()


{
var request = new DeleteItemRequest
{
TableName = tableName,
Key = new Dictionary<string, AttributeValue>()
{
{ "Id", new AttributeValue {
N = "1000"
} }
},

// Return the entire item as it appeared before the update.


ReturnValues = "ALL_OLD",
ExpressionAttributeNames = new Dictionary<string, string>()
{
{"#IP", "InPublication"}
},
ExpressionAttributeValues = new Dictionary<string, AttributeValue>()
{
{":inpub",new AttributeValue {
BOOL = false
}}
},
ConditionExpression = "#IP = :inpub"
};

var response = client.DeleteItem(request);

// Check the response.


var attributeList = response.Attributes; // Attribute list in the response.
// Print item.
Console.WriteLine("\nPrinting item that was just deleted ............");
PrintItem(attributeList);
}

private static void PrintItem(Dictionary<string, AttributeValue> attributeList)


{
foreach (KeyValuePair<string, AttributeValue> kvp in attributeList)
{
string attributeName = kvp.Key;
AttributeValue value = kvp.Value;

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("************************************************");
}
}
}

Versión de API 2012-08-10


488
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

Ejemplo: Operaciones Batch mediante elAWS SDK for .NETAPI


de bajo nivel
Temas
• Ejemplo: Operación de escritura por lotes mediante elAWS SDK for .NETAPI de bajo nivel (p. 489)
• Ejemplo: Operación de obtención por lotes mediante elAWS SDK for .NETAPI de bajo nivel (p. 492)

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:

• Colocar un elemento en la tabla Forum.


• Colocar un elemento y eliminar un elemento de la tabla Thread.

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;

Versión de API 2012-08-10


489
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

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

static void Main(string[] args)


{
try
{
TestBatchWrite();
}
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }

Console.WriteLine("To continue, press Enter");


Console.ReadLine();
}

private static void TestBatchWrite()


{
var request = new BatchWriteItemRequest
{
ReturnConsumedCapacity = "TOTAL",
RequestItems = new Dictionary<string, List<WriteRequest>>
{
{
table1Name, new List<WriteRequest>
{
new WriteRequest
{
PutRequest = new PutRequest
{
Item = new Dictionary<string, AttributeValue>
{
{ "Name", new AttributeValue {
S = "S3 forum"
} },
{ "Threads", new AttributeValue {
N = "0"
}}
}
}
}
}
},
{
table2Name, new List<WriteRequest>
{
new WriteRequest
{
PutRequest = new PutRequest
{
Item = new Dictionary<string, AttributeValue>
{
{ "ForumName", new AttributeValue {
S = "S3 forum"
} },
{ "Subject", new AttributeValue {
S = "My sample question"
} },
{ "Message", new AttributeValue {

Versión de API 2012-08-10


490
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

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

private static void CallBatchWriteTillCompletion(BatchWriteItemRequest request)


{
BatchWriteItemResponse response;

int callCount = 0;
do
{
Console.WriteLine("Making request");
response = client.BatchWriteItem(request);
callCount++;

// Check the response.

var tableConsumedCapacities = response.ConsumedCapacity;


var unprocessed = response.UnprocessedItems;

Console.WriteLine("Per-table consumed capacity");


foreach (var tableConsumedCapacity in tableConsumedCapacities)
{
Console.WriteLine("{0} - {1}", tableConsumedCapacity.TableName,
tableConsumedCapacity.CapacityUnits);
}

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.

Versión de API 2012-08-10


491
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

request.RequestItems = unprocessed;
} while (response.UnprocessedItems.Count > 0);

Console.WriteLine("Total # of batch write API calls made: {0}", callCount);


}
}
}

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

static void Main(string[] args)


{
try
{
RetrieveMultipleItemsBatchGet();

Console.WriteLine("To continue, press Enter");


Console.ReadLine();
}

Versión de API 2012-08-10


492
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

catch (AmazonServiceException e) { Console.WriteLine(e.Message); }


catch (Exception e) { Console.WriteLine(e.Message); }
}

private static void RetrieveMultipleItemsBatchGet()


{
var request = new BatchGetItemRequest
{
RequestItems = new Dictionary<string, KeysAndAttributes>()
{
{ table1Name,
new KeysAndAttributes
{
Keys = new List<Dictionary<string, AttributeValue> >()
{
new Dictionary<string, AttributeValue>()
{
{ "Name", new AttributeValue {
S = "Amazon DynamoDB"
} }
},
new Dictionary<string, AttributeValue>()
{
{ "Name", new AttributeValue {
S = "Amazon S3"
} }
}
}
}},
{
table2Name,
new KeysAndAttributes
{
Keys = new List<Dictionary<string, AttributeValue> >()
{
new Dictionary<string, AttributeValue>()
{
{ "ForumName", new AttributeValue {
S = "Amazon DynamoDB"
} },
{ "Subject", new AttributeValue {
S = "DynamoDB Thread 1"
} }
},
new Dictionary<string, AttributeValue>()
{
{ "ForumName", new AttributeValue {
S = "Amazon DynamoDB"
} },
{ "Subject", new AttributeValue {
S = "DynamoDB Thread 2"
} }
},
new Dictionary<string, AttributeValue>()
{
{ "ForumName", new AttributeValue {
S = "Amazon S3"
} },
{ "Subject", new AttributeValue {
S = "S3 Thread 1"
} }
}
}
}
}
}

Versión de API 2012-08-10


493
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

};

BatchGetItemResponse response;
do
{
Console.WriteLine("Making request");
response = client.BatchGetItem(request);

// Check the response.


var responses = response.Responses; // Attribute list in the response.

foreach (var tableResponse in responses)


{
var tableResults = tableResponse.Value;
Console.WriteLine("Items retrieved from table {0}", tableResponse.Key);
foreach (var item1 in tableResults)
{
PrintItem(item1);
}
}

// Any unprocessed keys? could happen if you exceed ProvisionedThroughput


or some other error.
Dictionary<string, KeysAndAttributes> unprocessedKeys =
response.UnprocessedKeys;
foreach (var unprocessedTableKeys in unprocessedKeys)
{
// Print table name.
Console.WriteLine(unprocessedTableKeys.Key);
// Print unprocessed primary keys.
foreach (var key in unprocessedTableKeys.Value.Keys)
{
PrintItem(key);
}
}

request.RequestItems = unprocessedKeys;
} while (response.UnprocessedKeys.Count > 0);
}

private static void PrintItem(Dictionary<string, AttributeValue> attributeList)


{
foreach (KeyValuePair<string, AttributeValue> kvp in attributeList)
{
string attributeName = kvp.Key;
AttributeValue value = kvp.Value;

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("************************************************");
}
}
}

Versión de API 2012-08-10


494
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

Ejemplo: Control de atributos de tipo Binary mediante elAWS


SDK for .NETAPI de bajo nivel
En el siguiente ejemplo de código C# se ilustra cómo se controlan los atributos de tipo Binary. Además, se
agrega un elemento a la tabla Reply. El elemento incluye un atributo de tipo Binary (ExtendedMessage)
que almacena datos comprimidos. A continuación, en el ejemplo se recupera el elemento y se
imprimen todos los valores de los atributos. Con fines ilustrativos, el ejemplo usa la clase GZipStream
para comprimir un ejemplo de secuencia y asignársela al atributo ExtendedMessage; después, la
descomprime al imprimir el valor del atributo.

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

static void Main(string[] args)


{
// Reply table primary key.
string replyIdPartitionKey = "Amazon DynamoDB#DynamoDB Thread 1";
string replyDateTimeSortKey = Convert.ToString(DateTime.UtcNow);

try
{
CreateItem(replyIdPartitionKey, replyDateTimeSortKey);
RetrieveItem(replyIdPartitionKey, replyDateTimeSortKey);
// Delete item.
DeleteItem(replyIdPartitionKey, replyDateTimeSortKey);

Versión de API 2012-08-10


495
Amazon DynamoDB Guía para desarrolladores
Uso de elementos: .NET

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

private static void CreateItem(string partitionKey, string sortKey)


{
MemoryStream compressedMessage = ToGzipMemoryStream("Some long extended message
to compress.");
var request = new PutItemRequest
{
TableName = tableName,
Item = new Dictionary<string, AttributeValue>()
{
{ "Id", new AttributeValue {
S = partitionKey
}},
{ "ReplyDateTime", new AttributeValue {
S = sortKey
}},
{ "Subject", new AttributeValue {
S = "Binary type "
}},
{ "Message", new AttributeValue {
S = "Some message about the binary type"
}},
{ "ExtendedMessage", new AttributeValue {
B = compressedMessage
}}
}
};
client.PutItem(request);
}

private static void RetrieveItem(string partitionKey, string sortKey)


{
var request = new GetItemRequest
{
TableName = tableName,
Key = new Dictionary<string, AttributeValue>()
{
{ "Id", new AttributeValue {
S = partitionKey
} },
{ "ReplyDateTime", new AttributeValue {
S = sortKey
} }
},
ConsistentRead = true
};
var response = client.GetItem(request);

// Check the response.


var attributeList = response.Item; // attribute list in the response.
Console.WriteLine("\nPrinting item after retrieving it ............");

PrintItem(attributeList);
}

private static void DeleteItem(string partitionKey, string sortKey)


{
var request = new DeleteItemRequest
{

Versión de API 2012-08-10


496
Amazon DynamoDB Guía para desarrolladores
Uso de consultas

TableName = tableName,
Key = new Dictionary<string, AttributeValue>()
{
{ "Id", new AttributeValue {
S = partitionKey
} },
{ "ReplyDateTime", new AttributeValue {
S = sortKey
} }
}
};
var response = client.DeleteItem(request);
}

private static void PrintItem(Dictionary<string, AttributeValue> attributeList)


{
foreach (KeyValuePair<string, AttributeValue> kvp in attributeList)
{
string attributeName = kvp.Key;
AttributeValue value = kvp.Value;

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("************************************************");
}

private static MemoryStream ToGzipMemoryStream(string value)


{
MemoryStream output = new MemoryStream();
using (GZipStream zipStream = new GZipStream(output, CompressionMode.Compress,
true))
using (StreamWriter writer = new StreamWriter(zipStream))
{
writer.Write(value);
}
return output;
}

private static string FromGzipMemoryStream(MemoryStream stream)


{
using (GZipStream zipStream = new GZipStream(stream,
CompressionMode.Decompress))
using (StreamReader reader = new StreamReader(zipStream))
{
return reader.ReadToEnd();
}
}
}
}

Uso de consultas en DynamoDB


LaQueryEn Amazon DynamoDB busca elementos según los valores de clave principal.

Versión de API 2012-08-10


497
Amazon DynamoDB Guía para desarrolladores
Expresiones de condición de clave

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)

Expresiones de condición de clave


Para especificar los criterios de búsqueda, se utiliza una expresión de condición de clave; se trata de una
cadena que determina los elementos que se van a leer en la tabla o el índice.

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:

• a = b: es true si el atributo a es igual al valor b.


• a < b: es true si a es menor que b.
• a <= b: es true si a es menor o igual que b.
• a > b: es true si a es mayor que b.
• a >= b: es true si a es mayor o igual que b.
• a BETWEEN b AND c: es true si a es mayor o igual que b y menor o igual que c.

También se admite la siguiente funció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.

aws dynamodb query \


--table-name Thread \

Versión de API 2012-08-10


498
Amazon DynamoDB Guía para desarrolladores
Expresiones de condición de clave

--key-condition-expression "ForumName = :name" \


--expression-attribute-values '{":name":{"S":"Amazon DynamoDB"}}'

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

aws dynamodb query \


--table-name Thread \
--key-condition-expression "ForumName = :name and Subject = :sub" \
--expression-attribute-values file://values.json

Los argumentos de --expression-attribute-values se almacenan en el archivo values.json.

{
":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.

aws dynamodb query \


--table-name Reply \
--key-condition-expression "Id = :id and begins_with(ReplyDateTime, :dt)" \
--expression-attribute-values file://values.json

Los argumentos de --expression-attribute-values se almacenan en el archivo values.json.

{
":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.

Una operación Query siempre devuelve un conjunto de resultados. Si no se encuentran elementos


coincidentes, el conjunto de resultados está vacío.

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.

Versión de API 2012-08-10


499
Amazon DynamoDB Guía para desarrolladores
Expresiones de filtro para Query

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

Expresiones de filtro para Query


Si tiene que refinar más los resultados de Query, si lo desea puede indicar una expresión de filtro. Una
expresión de filtro determina qué elementos de los resultados de Query se deben devolver al usuario.
Todos los demás resultados se descartan.

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.

aws dynamodb query \


--table-name Thread \
--key-condition-expression "ForumName = :fn and Subject = :sub" \
--filter-expression "#v >= :num" \
--expression-attribute-names '{"#v": "Views"}' \
--expression-attribute-values file://values.json

Los argumentos de --expression-attribute-values se almacenan en el archivo values.json.

{
":fn":{"S":"Amazon DynamoDB"},
":sub":{"S":"DynamoDB Thread 1"},
":num":{"N":"3"}
}

Tenga en cuenta queViewses una palabra reservada en DynamoDB (consultePalabras reservadas en


DynamoDB (p. 1135)), por lo que este ejemplo utiliza#vcomo marcador de posición. Para obtener más
información, consulte Nombres de atributos de expresión en DynamoDB (p. 425).

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.

Versión de API 2012-08-10


500
Amazon DynamoDB Guía para desarrolladores
Limitación del número de elementos
del conjunto de resultados

Limitación del número de elementos del conjunto de


resultados
La operación Query permite limitar el número de elementos que lee. Para ello, establezca el parámetro
Limit en el número máximo de elementos que desee.

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.

Paginación de resultados de la consulta de tabla


DynamoDBpaginadosLos resultados deQueryoperaciones. Con la paginación, elQueryLos resultados
se dividen en «páginas» de datos con un tamaño de 1 MB (o menos). Una aplicación puede procesar la
primera página de resultados, luego la segunda página, y así sucesivamente.

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:

1. Examinar el resultado de Query de bajo nivel:


• Si el resultado contiene unLastEvaluatedKeyelemento y no es nulo, vaya al paso 2.
• Si no figura LastEvaluatedKey en el resultado, no hay más elementos que recuperar.
2. Crear una nueva solicitud Query con los mismos parámetros que la anterior. Sin embargo, esta vez, se
toma el valor LastEvaluatedKey del paso 1 y se usa como parámetro ExclusiveStartKey en la
nueva solicitud Query.
3. Ejecutar la nueva solicitud Query.
4. Ir al paso 1.

Es decir, el valor de LastEvaluatedKey de la respuesta de Query debe utilizarse como valor de


ExclusiveStartKey en la siguiente solicitud Query. Si no hay una entrada LastEvaluatedKey
en una respuesta de Query, significa que se ha recuperado la última página de resultados. Si
LastEvaluatedKey no está vacía, no significa necesariamente que haya más datos en el conjunto de
resultados. La única forma de saber que se ha alcanzado el final del conjunto de resultados es cuando
LastEvaluatedKey está vacío.

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:

aws dynamodb query --table-name Movies \


--projection-expression "title" \
--key-condition-expression "#y = :yyyy" \
--expression-attribute-names '{"#y":"year"}' \
--expression-attribute-values '{":yyyy":{"N":"1993"}}' \
--page-size 5 \
--debug

Versión de API 2012-08-10


501
Amazon DynamoDB Guía para desarrolladores
Recuento de los elementos de los resultados

Normalmente, la AWS CLI se encarga de la paginación automáticamente. No obstante, en este ejemplo, el


parámetro --page-size de la AWS CLI limita el número de elementos por página. El parámetro --debug
muestra información de bajo nivel de las solicitudes y las respuestas.

Si ejecuta el ejemplo, la primera respuesta de DynamoDB será similar a la siguiente.

2017-07-07 11:13:15,603 - MainThread - botocore.parsers - DEBUG - Response body:


b'{"Count":5,"Items":[{"title":{"S":"A Bronx Tale"}},
{"title":{"S":"A Perfect World"}},{"title":{"S":"Addams Family Values"}},
{"title":{"S":"Alive"}},{"title":{"S":"Benny & Joon"}}],
"LastEvaluatedKey":{"year":{"N":"1993"},"title":{"S":"Benny & Joon"}},
"ScannedCount":5}'

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.

2017-07-07 11:13:16,291 - MainThread - botocore.parsers - DEBUG - Response body:


b'{"Count":1,"Items":[{"title":{"S":"What\'s Eating Gilbert Grape"}}],"ScannedCount":1}'

La ausencia de LastEvaluatedKey indica que no hay más elementos que recuperar.


Note

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

Recuento de los elementos de los resultados


Además de los elementos que coinciden con los criterios, la respuesta de Query contiene las entradas
siguientes:

• ScannedCount— El número de elementos que coincidían con la expresión de condición de


claveBEFORESe aplicó una expresión de filtro (si la hay).
• Count: número de elementos restantesDESTERSe aplicó una expresión de filtro (si la hay).

Note

Si no se utiliza una expresión de filtro, ScannedCount y Count tendrán el mismo valor.

Si el tamaño de la propiedadQueryel conjunto de resultados es mayor que 1


MB,ScannedCountyCountrepresentan solamente un recuento parcial de los elementos totales. Deberá
llevar a cabo varias operaciones Query para recuperar todos los resultados (consulte Paginación de
resultados de la consulta de tabla (p. 501)).

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.

Versión de API 2012-08-10


502
Amazon DynamoDB Guía para desarrolladores
Unidades de capacidad que Query consume

Unidades de capacidad que Query consume


Puede hacer lo siguienteQueryCualquier tabla o índice secundario, siempre y cuando tenga una clave
principal compuesta (una clave de partición y una clave de ordenación).QueryLas operaciones consumen
unidades de capacidad de lectura como se indica a continuación.

Si Query se aplica a... DynamoDB consume unidades de capacidad de


lectura de...

Tabla La capacidad de lectura aprovisionada de la tabla.

Índices secundarios mundiales La capacidad de lectura aprovisionada del índice.

Índices secundarios locales La capacidad de lectura aprovisionada de la tabla


base.

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:

• NONE: no se devuelven datos de capacidad consumida. (Esta es la opción predeterminada.)


• TOTAL: la respuesta incluye el número total de unidades de capacidad de lectura consumidas.
• INDEXES: la respuesta muestra el número total de unidades de capacidad de lectura consumidas, así
como la capacidad consumida de cada tabla e índice a los que se ha obtenido acceso.

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.

Consistencia de lectura de Query


De forma predeterminada, una operación Query lleva a cabo lecturas consistentes finales. Esto significa
que los resultados de Query podrían no reflejar los cambios provocados por operaciones PutItem
o UpdateItem realizadas recientemente. Para obtener más información, consulte Consistencia de
lectura (p. 17).

Si requiere lecturas de consistencia alta, establezca el parámetro ConsistentRead en true en la


solicitud Query.

Consulta de tablas e índices: Java


LaQueryLa operación permite consultar una tabla o un índice secundario en Amazon DynamoDB. Debe
proporcionar un valor de clave de partición y una condición de igualdad. Si la tabla o el índice tienen una
clave de ordenación, puede refinar los resultados proporcionando un valor de clave de ordenación y una
condición.
Note

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

Versión de API 2012-08-10


503
Amazon DynamoDB Guía para desarrolladores
Consulta: Java

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.

1. Cree una instancia de la clase DynamoDB.


2. Cree una instancia de la clase Table para representar la tabla que desea usar.
3. Llame al método query de la instancia de Table. Debe especificar el valor de clave de partición de
los elementos que desea recuperar, junto con los parámetros de consulta opcionales.

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

Reply ( Id, ReplyDateTime, ... )

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

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()


.withRegion(Regions.US_WEST_2).build();
DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("Reply");

QuerySpec spec = new QuerySpec()


.withKeyConditionExpression("Id = :v_id")
.withValueMap(new ValueMap()
.withString(":v_id", "Amazon DynamoDB#DynamoDB Thread 1"));

ItemCollection<QueryOutcome> items = table.query(spec);

Iterator<Item> iterator = items.iterator();


Item item = null;
while (iterator.hasNext()) {
item = iterator.next();
System.out.println(item.toJSONPretty());
}

Especificación de parámetros opcionales


El método query admite varios parámetros opcionales. Por ejemplo, si lo desea puede especificar una
condición para delimitar los resultados de la consulta anterior y que se devuelvan las respuestas de las
dos últimas semanas. La condición se denomina condición de clave de ordenación, ya que DynamoDB
evalúa la condición de consulta que se ha especificado con respecto a la clave de ordenación de la clave
principal. Puede especificar otros parámetros opcionales para recuperar solo una lista específica de
atributos de los elementos presentes en el resultado de la consulta.

Versión de API 2012-08-10


504
Amazon DynamoDB Guía para desarrolladores
Consulta: Java

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:

• Una expresión KeyConditionExpression para recuperar las respuestas de un foro de debate


concreto (clave de partición) y, dentro de ese conjunto de elementos, las respuestas que se han
publicado en los últimos 15 días (clave de ordenación).
• Una expresión FilterExpression para devolver solamente las respuestas de un usuario
determinado. El filtro se aplica después de procesar la consulta, pero antes de devolver los resultados al
usuario.
• Un mapa ValueMap para definir los valores reales de los marcadores de posición de
KeyConditionExpression.
• ConsistentRead establecido en true, para solicitar una lectura de consistencia alta.

En este ejemplo se utiliza un objeto QuerySpec que proporciona acceso a todos los parámetros de
entrada de bajo nivel de Query.

Example

Table table = dynamoDB.getTable("Reply");

long twoWeeksAgoMilli = (new Date()).getTime() - (15L*24L*60L*60L*1000L);


Date twoWeeksAgo = new Date();
twoWeeksAgo.setTime(twoWeeksAgoMilli);
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
String twoWeeksAgoStr = df.format(twoWeeksAgo);

QuerySpec spec = new QuerySpec()


.withKeyConditionExpression("Id = :v_id and ReplyDateTime > :v_reply_dt_tm")
.withFilterExpression("PostedBy = :v_posted_by")
.withValueMap(new ValueMap()
.withString(":v_id", "Amazon DynamoDB#DynamoDB Thread 1")
.withString(":v_reply_dt_tm", twoWeeksAgoStr)
.withString(":v_posted_by", "User B"))
.withConsistentRead(true);

ItemCollection<QueryOutcome> items = table.query(spec);

Iterator<Item> iterator = items.iterator();


while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}

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.

En el siguiente ejemplo de código Java se modifica la especificación de consulta mostrada anteriormente.


Esta vez, la especificación de consulta utiliza el método withMaxPageSize. La clase Page proporciona
un iterador que permite que el código procese los elementos de cada página.

Example

spec.withMaxPageSize(10);

ItemCollection<QueryOutcome> items = table.query(spec);

Versión de API 2012-08-10


505
Amazon DynamoDB Guía para desarrolladores
Consulta: Java

// Process each page of results


int pageNum = 0;
for (Page<Item, QueryOutcome> page : items.pages()) {

System.out.println("\nPage: " + ++pageNum);

// Process each item on the current page


Iterator<Item> item = page.iterator();
while (item.hasNext()) {
System.out.println(item.next().toJSONPretty());
}
}

Ejemplo: Consulta mediante Java


En las siguientes tablas se almacena información sobre una colección de foros. Para obtener
más información, consulte Creación de tablas y carga de datos para ejemplos de código en
DynamoDB (p. 333).
Note

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

Forum ( Name, ... )


Thread ( ForumName, Subject, Message, LastPostedBy, LastPostDateTime, ...)
Reply ( Id, ReplyDateTime, Message, PostedBy, ...)

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

• Buscar las respuestas a una conversación.


• Buscar las respuestas a una conversación, especificando un límite para el número de elementos que
contendrá cada página de resultados. Si el número de elementos del conjunto de resultados supera el
tamaño de página, se obtiene únicamente 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.

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

/**

Versión de API 2012-08-10


506
Amazon DynamoDB Guía para desarrolladores
Consulta: 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.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;

public class DocumentAPIQuery {

static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


static DynamoDB dynamoDB = new DynamoDB(client);

static String tableName = "Reply";

public static void main(String[] args) throws Exception {

String forumName = "Amazon DynamoDB";


String threadSubject = "DynamoDB Thread 1";

findRepliesForAThread(forumName, threadSubject);
findRepliesForAThreadSpecifyOptionalLimit(forumName, threadSubject);
findRepliesInLast15DaysWithConfig(forumName, threadSubject);
findRepliesPostedWithinTimePeriod(forumName, threadSubject);
findRepliesUsingAFilterExpression(forumName, threadSubject);
}

private static void findRepliesForAThread(String forumName, String threadSubject) {

Table table = dynamoDB.getTable(tableName);

String replyId = forumName + "#" + threadSubject;

QuerySpec spec = new QuerySpec().withKeyConditionExpression("Id = :v_id")


.withValueMap(new ValueMap().withString(":v_id", replyId));

ItemCollection<QueryOutcome> items = table.query(spec);

System.out.println("\nfindRepliesForAThread results:");

Iterator<Item> iterator = items.iterator();


while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());

Versión de API 2012-08-10


507
Amazon DynamoDB Guía para desarrolladores
Consulta: Java

private static void findRepliesForAThreadSpecifyOptionalLimit(String forumName, String


threadSubject) {

Table table = dynamoDB.getTable(tableName);

String replyId = forumName + "#" + threadSubject;

QuerySpec spec = new QuerySpec().withKeyConditionExpression("Id = :v_id")


.withValueMap(new ValueMap().withString(":v_id", replyId)).withMaxPageSize(1);

ItemCollection<QueryOutcome> items = table.query(spec);

System.out.println("\nfindRepliesForAThreadSpecifyOptionalLimit results:");

// Process each page of results


int pageNum = 0;
for (Page<Item, QueryOutcome> page : items.pages()) {

System.out.println("\nPage: " + ++pageNum);

// Process each item on the current page


Iterator<Item> item = page.iterator();
while (item.hasNext()) {
System.out.println(item.next().toJSONPretty());
}
}
}

private static void findRepliesInLast15DaysWithConfig(String forumName, String


threadSubject) {

Table table = dynamoDB.getTable(tableName);

long twoWeeksAgoMilli = (new Date()).getTime() - (15L * 24L * 60L * 60L * 1000L);


Date twoWeeksAgo = new Date();
twoWeeksAgo.setTime(twoWeeksAgoMilli);
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
String twoWeeksAgoStr = df.format(twoWeeksAgo);

String replyId = forumName + "#" + threadSubject;

QuerySpec spec = new QuerySpec().withProjectionExpression("Message, ReplyDateTime,


PostedBy")
.withKeyConditionExpression("Id = :v_id and ReplyDateTime <= :v_reply_dt_tm")
.withValueMap(new ValueMap().withString(":v_id",
replyId).withString(":v_reply_dt_tm", twoWeeksAgoStr));

ItemCollection<QueryOutcome> items = table.query(spec);

System.out.println("\nfindRepliesInLast15DaysWithConfig results:");
Iterator<Item> iterator = items.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}

private static void findRepliesPostedWithinTimePeriod(String forumName, String


threadSubject) {

Table table = dynamoDB.getTable(tableName);

Versión de API 2012-08-10


508
Amazon DynamoDB Guía para desarrolladores
Consulta: .NET

long startDateMilli = (new Date()).getTime() - (15L * 24L * 60L * 60L * 1000L);


long endDateMilli = (new Date()).getTime() - (5L * 24L * 60L * 60L * 1000L);
java.text.SimpleDateFormat df = new java.text.SimpleDateFormat("yyyy-MM-
dd'T'HH:mm:ss.SSS'Z'");
String startDate = df.format(startDateMilli);
String endDate = df.format(endDateMilli);

String replyId = forumName + "#" + threadSubject;

QuerySpec spec = new QuerySpec().withProjectionExpression("Message, ReplyDateTime,


PostedBy")
.withKeyConditionExpression("Id = :v_id and ReplyDateTime between :v_start_dt
and :v_end_dt")
.withValueMap(new ValueMap().withString(":v_id",
replyId).withString(":v_start_dt", startDate)
.withString(":v_end_dt", endDate));

ItemCollection<QueryOutcome> items = table.query(spec);

System.out.println("\nfindRepliesPostedWithinTimePeriod results:");
Iterator<Item> iterator = items.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}
}

private static void findRepliesUsingAFilterExpression(String forumName, String


threadSubject) {

Table table = dynamoDB.getTable(tableName);

String replyId = forumName + "#" + threadSubject;

QuerySpec spec = new QuerySpec().withProjectionExpression("Message, ReplyDateTime,


PostedBy")
.withKeyConditionExpression("Id = :v_id").withFilterExpression("PostedBy
= :v_postedby")
.withValueMap(new ValueMap().withString(":v_id",
replyId).withString(":v_postedby", "User B"));

ItemCollection<QueryOutcome> items = table.query(spec);

System.out.println("\nfindRepliesUsingAFilterExpression results:");
Iterator<Item> iterator = items.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}
}

Consulta de tablas e índices: .NET


LaQueryLa operación permite consultar una tabla o un índice secundario en Amazon DynamoDB. Debe
proporcionar un valor de clave de partición y una condición de igualdad. Si la tabla o el índice tienen una
clave de ordenación, puede refinar los resultados proporcionando un valor de clave de ordenación y una
condición.

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.

1. Cree una instancia de la clase AmazonDynamoDBClient.

Versión de API 2012-08-10


509
Amazon DynamoDB Guía para desarrolladores
Consulta: .NET

2. Cree una instancia de la clase QueryRequest y proporcione los parámetros de la operación de


consulta.
3. Ejecute laQueryy proporcionar el métodoQueryRequestObjeto que creó en el paso anterior.

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

Reply Id, ReplyDateTime, ... )

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

AmazonDynamoDBClient client = new AmazonDynamoDBClient();

var request = new QueryRequest


{
TableName = "Reply",
KeyConditionExpression = "Id = :v_Id",
ExpressionAttributeValues = new Dictionary<string, AttributeValue> {
{":v_Id", new AttributeValue { S = "Amazon DynamoDB#DynamoDB Thread 1" }}}
};

var response = client.Query(request);

foreach (Dictionary<string, AttributeValue> item in response.Items)


{
// Process the result.
PrintItem(item);
}

Especificación de parámetros opcionales


El método Query admite varios parámetros opcionales. Por ejemplo, si lo desea puede especificar una
condición para delimitar el resultado de la consulta anterior y que se devuelvan las respuestas de las
dos últimas semanas. La condición se denomina: condición de clave de ordenación, ya que DynamoDB
evalúa la condición de consulta que se ha especificado con respecto a la clave de ordenación de la
clave principal. Puede especificar otros parámetros opcionales para recuperar solo una lista específica
de atributos de los elementos presentes en el resultado de la consulta. Para obtener más información,
consulteConsulta.

En el siguiente ejemplo de código C# se recuperan las respuestas de las conversaciones de un foro


publicadas en los últimos 15 días. En el ejemplo se especifican los parámetros opcionales siguientes:

• Una expresión KeyConditionExpression para recuperar solamente las respuestas de los últimos
15 días.

Versión de API 2012-08-10


510
Amazon DynamoDB Guía para desarrolladores
Consulta: .NET

• 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

DateTime twoWeeksAgoDate = DateTime.UtcNow - TimeSpan.FromDays(15);


string twoWeeksAgoString = twoWeeksAgoDate.ToString(AWSSDKUtils.ISO8601DateFormat);

var request = new QueryRequest


{
TableName = "Reply",
KeyConditionExpression = "Id = :v_Id and ReplyDateTime > :v_twoWeeksAgo",
ExpressionAttributeValues = new Dictionary<string, AttributeValue> {
{":v_Id", new AttributeValue { S = "Amazon DynamoDB#DynamoDB Thread 2" }},
{":v_twoWeeksAgo", new AttributeValue { S = twoWeeksAgoString }}
},
ProjectionExpression = "Subject, ReplyDateTime, PostedBy",
ConsistentRead = true
};

var response = client.Query(request);

foreach (Dictionary<string, AttributeValue> item in response.Items)


{
// Process the result.
PrintItem(item);
}

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.

En el siguiente ejemplo de C# se consulta la tabla Reply. En la solicitud, se especifican los parámetros


opcionales Limit y ExclusiveStartKey. El bucle do/while continúa examinando una página cada
vez hasta que LastEvaluatedKey devuelve el valor null.

Example

Dictionary<string,AttributeValue> lastKeyEvaluated = null;

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
};

Versión de API 2012-08-10


511
Amazon DynamoDB Guía para desarrolladores
Consulta: .NET

var response = client.Query(request);

// Process the query result.


foreach (Dictionary<string, AttributeValue> item in response.Items)
{
PrintItem(item);
}

lastKeyEvaluated = response.LastEvaluatedKey;

} while (lastKeyEvaluated != null && lastKeyEvaluated.Count != 0);

Ejemplo: Consulta mediante la propiedadAWS SDK for .NET


En las siguientes tablas se almacena información sobre una colección de foros. 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

Forum ( Name, ... )


Thread ( ForumName, Subject, Message, LastPostedBy, LastPostDateTime, ...)
Reply ( Id, ReplyDateTime, Message, PostedBy, ...)

En este ejemplo, puede ejecutar variaciones de la búsqueda de respuestas para la conversación


«DynamoDB Thread 1" del foro «DynamoDB».

• Buscar las respuestas a una conversación.


• Buscar las respuestas a una conversación. Especificar el parámetro Limit de la consulta para
establecer el tamaño de la página.

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.

Versión de API 2012-08-10


512
Amazon DynamoDB Guía para desarrolladores
Consulta: .NET

*/
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();

static void Main(string[] args)


{
try
{
// Query a specific forum and thread.
string forumName = "Amazon DynamoDB";
string threadSubject = "DynamoDB Thread 1";

FindRepliesForAThread(forumName, threadSubject);
FindRepliesForAThreadSpecifyOptionalLimit(forumName, threadSubject);
FindRepliesInLast15DaysWithConfig(forumName, threadSubject);
FindRepliesPostedWithinTimePeriod(forumName, threadSubject);

Console.WriteLine("Example complete. To continue, press Enter");


Console.ReadLine();
}
catch (AmazonDynamoDBException e) { Console.WriteLine(e.Message);
Console.ReadLine(); }
catch (AmazonServiceException e) { Console.WriteLine(e.Message);
Console.ReadLine(); }
catch (Exception e) { Console.WriteLine(e.Message); Console.ReadLine(); }
}

private static void FindRepliesPostedWithinTimePeriod(string forumName, string


threadSubject)
{
Console.WriteLine("*** Executing FindRepliesPostedWithinTimePeriod() ***");
string replyId = forumName + "#" + threadSubject;
// You must provide date value based on your test data.
DateTime startDate = DateTime.UtcNow - TimeSpan.FromDays(21);
string start = startDate.ToString(AWSSDKUtils.ISO8601DateFormat);

// You provide date value based on your test data.


DateTime endDate = DateTime.UtcNow - TimeSpan.FromDays(5);
string end = endDate.ToString(AWSSDKUtils.ISO8601DateFormat);

var request = new QueryRequest


{
TableName = "Reply",
ReturnConsumedCapacity = "TOTAL",
KeyConditionExpression = "Id = :v_replyId and ReplyDateTime
between :v_start and :v_end",
ExpressionAttributeValues = new Dictionary<string, AttributeValue> {
{":v_replyId", new AttributeValue {
S = replyId
}},
{":v_start", new AttributeValue {
S = start
}},
{":v_end", new AttributeValue {
S = end
}}

Versión de API 2012-08-10


513
Amazon DynamoDB Guía para desarrolladores
Consulta: .NET

}
};

var response = client.Query(request);

Console.WriteLine("\nNo. of reads used (by query in


FindRepliesPostedWithinTimePeriod) {0}",
response.ConsumedCapacity.CapacityUnits);
foreach (Dictionary<string, AttributeValue> item
in response.Items)
{
PrintItem(item);
}
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}

private static void FindRepliesInLast15DaysWithConfig(string forumName, string


threadSubject)
{
Console.WriteLine("*** Executing FindRepliesInLast15DaysWithConfig() ***");
string replyId = forumName + "#" + threadSubject;

DateTime twoWeeksAgoDate = DateTime.UtcNow - TimeSpan.FromDays(15);


string twoWeeksAgoString =
twoWeeksAgoDate.ToString(AWSSDKUtils.ISO8601DateFormat);

var request = new QueryRequest


{
TableName = "Reply",
ReturnConsumedCapacity = "TOTAL",
KeyConditionExpression = "Id = :v_replyId and ReplyDateTime > :v_interval",
ExpressionAttributeValues = new Dictionary<string, AttributeValue> {
{":v_replyId", new AttributeValue {
S = replyId
}},
{":v_interval", new AttributeValue {
S = twoWeeksAgoString
}}
},

// Optional parameter.
ProjectionExpression = "Id, ReplyDateTime, PostedBy",
// Optional parameter.
ConsistentRead = true
};

var response = client.Query(request);

Console.WriteLine("No. of reads used (by query in


FindRepliesInLast15DaysWithConfig) {0}",
response.ConsumedCapacity.CapacityUnits);
foreach (Dictionary<string, AttributeValue> item
in response.Items)
{
PrintItem(item);
}
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}

private static void FindRepliesForAThreadSpecifyOptionalLimit(string forumName,


string threadSubject)
{
Console.WriteLine("*** Executing FindRepliesForAThreadSpecifyOptionalLimit()
***");

Versión de API 2012-08-10


514
Amazon DynamoDB Guía para desarrolladores
Consulta: .NET

string replyId = forumName + "#" + threadSubject;

Dictionary<string, AttributeValue> lastKeyEvaluated = null;


do
{
var request = new QueryRequest
{
TableName = "Reply",
ReturnConsumedCapacity = "TOTAL",
KeyConditionExpression = "Id = :v_replyId",
ExpressionAttributeValues = new Dictionary<string, AttributeValue> {
{":v_replyId", new AttributeValue {
S = replyId
}}
},
Limit = 2, // The Reply table has only a few sample items. So the page
size is smaller.
ExclusiveStartKey = lastKeyEvaluated
};

var response = client.Query(request);

Console.WriteLine("No. of reads used (by query in


FindRepliesForAThreadSpecifyLimit) {0}\n",
response.ConsumedCapacity.CapacityUnits);
foreach (Dictionary<string, AttributeValue> item
in response.Items)
{
PrintItem(item);
}
lastKeyEvaluated = response.LastEvaluatedKey;
} while (lastKeyEvaluated != null && lastKeyEvaluated.Count != 0);

Console.WriteLine("To continue, press Enter");

Console.ReadLine();
}

private static void FindRepliesForAThread(string forumName, string threadSubject)


{
Console.WriteLine("*** Executing FindRepliesForAThread() ***");
string replyId = forumName + "#" + threadSubject;

var request = new QueryRequest


{
TableName = "Reply",
ReturnConsumedCapacity = "TOTAL",
KeyConditionExpression = "Id = :v_replyId",
ExpressionAttributeValues = new Dictionary<string, AttributeValue> {
{":v_replyId", new AttributeValue {
S = replyId
}}
}
};

var response = client.Query(request);


Console.WriteLine("No. of reads used (by query in FindRepliesForAThread)
{0}\n",
response.ConsumedCapacity.CapacityUnits);
foreach (Dictionary<string, AttributeValue> item in response.Items)
{
PrintItem(item);
}
Console.WriteLine("To continue, press Enter");
Console.ReadLine();

Versión de API 2012-08-10


515
Amazon DynamoDB Guía para desarrolladores
Uso de operaciones de examen

private static void PrintItem(


Dictionary<string, AttributeValue> attributeList)
{
foreach (KeyValuePair<string, AttributeValue> kvp in attributeList)
{
string attributeName = kvp.Key;
AttributeValue value = kvp.Value;

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("************************************************");
}
}
}

Uso de operaciones de examen en DynamoDB


AScanLa operación lee todos los elementos de una tabla o un índice secundario. De manera
predeterminada, una operación Scan devuelve todos los atributos de datos de todos los elementos de
la tabla o el índice. Puede utilizar el parámetro ProjectionExpression para que Scan solo devuelva
algunos de los atributos, en lugar de todos ellos.

Scan siempre devuelve un conjunto de resultados. Si no se encuentran elementos coincidentes, el


conjunto de resultados está vacío.

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)

Expresiones de filtro para Scan


Si tiene que refinar más los resultados de Scan, si lo desea puede indicar una expresión de filtro. Una
expresión de filtro determina qué elementos de los resultados de Scan se deben devolver al usuario.
Todos los demás resultados se descartan.

Versión de API 2012-08-10


516
Amazon DynamoDB Guía para desarrolladores
Limitación del número de elementos
del conjunto de resultados

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.

aws dynamodb scan \


--table-name Thread \
--filter-expression "LastPostedBy = :name" \
--expression-attribute-values '{":name":{"S":"User A"}}'

Limitación del número de elementos del conjunto de


resultados
La operación Scan permite limitar el número de elementos que devuelve en el resultado. Para ello,
establezca el parámetro Limit en el número máximo de elementos que desea que devuelva la operación
Scan, antes de la evaluación de la expresión de filtro.

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.

Paginación de los resultados


DynamoDBpaginarLos resultados deScanOperaciones. Con la paginación, elScanLos resultados se
dividen en «páginas» de datos con un tamaño de 1 MB (o menos). Una aplicación puede procesar la
primera página de resultados, luego la segunda página, y así sucesivamente.

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:

1. Examinar el resultado de Scan de bajo nivel:

• Si el resultado contiene una entrada LastEvaluatedKey, vaya al paso 2.


• Si no figura LastEvaluatedKey en el resultado, no hay más elementos que recuperar.
2. Crear una nueva solicitud Scan con los mismos parámetros que la anterior. Sin embargo, esta vez, se
toma el valor LastEvaluatedKey del paso 1 y se usa como parámetro ExclusiveStartKey en la
nueva solicitud Scan.
3. Ejecutar la nueva solicitud Scan.

Versión de API 2012-08-10


517
Amazon DynamoDB Guía para desarrolladores
Recuento de los elementos de los resultados

4. Ir al paso 1.

Es decir, el valor de LastEvaluatedKey de la respuesta de Scan debe utilizarse como valor de


ExclusiveStartKey en la siguiente solicitud Scan. Si no hay un componente LastEvaluatedKey en
una respuesta de Scan, significa que se ha recuperado la última página de resultados. La ausencia de
LastEvaluatedKey es la única forma de saber que se ha alcanzado el final del conjunto de resultados.

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.

aws dynamodb scan \


--table-name Movies \
--projection-expression "title" \
--filter-expression 'contains(info.genres,:gen)' \
--expression-attribute-values '{":gen":{"S":"Sci-Fi"}}' \
--page-size 100 \
--debug

Normalmente, la AWS CLI se encarga de la paginación automáticamente. No obstante, en este ejemplo, el


parámetro --page-size de la AWS CLI limita el número de elementos por página. El parámetro --debug
muestra información de bajo nivel de las solicitudes y las respuestas.

Si ejecuta el ejemplo, la primera respuesta de DynamoDB será similar a la siguiente.

2017-07-07 12:19:14,389 - MainThread - botocore.parsers - DEBUG - Response body:


b'{"Count":7,"Items":[{"title":{"S":"Monster on the Campus"}},{"title":{"S":"+1"}},
{"title":{"S":"100 Degrees Below Zero"}},{"title":{"S":"About Time"}},{"title":{"S":"After
Earth"}},
{"title":{"S":"Age of Dinosaurs"}},{"title":{"S":"Cloudy with a Chance of Meatballs 2"}}],
"LastEvaluatedKey":{"year":{"N":"2013"},"title":{"S":"Curse of
Chucky"}},"ScannedCount":100}'

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.

2017-07-07 12:19:17,830 - MainThread - botocore.parsers - DEBUG - Response body:


b'{"Count":1,"Items":[{"title":{"S":"WarGames"}}],"ScannedCount":6}'

La ausencia de LastEvaluatedKey indica que no hay más elementos que recuperar.


Note

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.

Recuento de los elementos de los resultados


Además de los elementos que coinciden con los criterios, la respuesta de Scan contiene las entradas
siguientes:

Versión de API 2012-08-10


518
Amazon DynamoDB Guía para desarrolladores
Unidades de capacidad que Scan consume

• ScannedCount— El número de elementos evaluados antes de cualquierScanFilterSe aplica. Un


valor de ScannedCount elevado, con pocos resultados de Count o ninguno indica que la operación
Scan ha sido ineficiente. Si no ha utilizado un filtro en la solicitud, ScannedCount es igual que Count.
• Count— El número de elementos que quedan;DespuésSe aplicó una expresión de filtro (si la hay).

Note

Si no se utiliza una expresión de filtro, ScannedCount y Count tendrán el mismo valor.

Si el tamaño de laScanel conjunto de resultados es mayor que 1 MB,ScannedCountyCountrepresentan


solo un recuento parcial del total de elementos. Deberá llevar a cabo varias operaciones Scan para
recuperar todos los resultados (consulte Paginación de los resultados (p. 517)).

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.

Unidades de capacidad que Scan consume


Puede hacer lo siguienteScancualquier tabla o índice secundario.ScanLas operaciones consumen
unidades de capacidad de lectura, de la siguiente.

Si Scan se aplica a... DynamoDB consume unidades de capacidad de


lectura de...

Tabla La capacidad de lectura aprovisionada de la tabla.

Índice secundario mundial La capacidad de lectura aprovisionada del índice.

Índice secundario local La capacidad de lectura aprovisionada de la tabla


base.

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:

• NONE: no se devuelven datos de capacidad consumida. (Esta es la opción predeterminada.)


• TOTAL: la respuesta incluye el número total de unidades de capacidad de lectura consumidas.
• INDEXES: la respuesta muestra el número total de unidades de capacidad de lectura consumidas, así
como la capacidad consumida de cada tabla e índice a los que se ha obtenido acceso.

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.

Consistencia de lectura de Scan


De forma predeterminada, una operación Scan lleva a cabo lecturas consistentes finales. Esto significa
que los resultados de Scan podrían no reflejar los cambios provocados por operaciones PutItem

Versión de API 2012-08-10


519
Amazon DynamoDB Guía para desarrolladores
Examen en paralelo

o UpdateItem realizadas recientemente. Para obtener más información, consulte Consistencia de


lectura (p. 17).

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.

Configuración deConsistentReadDe atruePuede resultar útil para realizar copias de seguridad


o replicaciones de tablas, junto conDynamoDB Streams. En primer lugar, se utiliza Scan con
ConsistentRead establecido en true para obtener una copia consistente de los datos de la tabla.
Durante laScan, DynamoDB Streams registra la actividad de escritura adicional que se produce en la tabla.
Una vez que la operación Scan ha finalizado, puede aplicar la actividad de escritura de la secuencia a la
tabla.
Note

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.

Versión de API 2012-08-10


520
Amazon DynamoDB Guía para desarrolladores
Examen en paralelo

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.

Los valores deSegmentyTotalSegmentsAplicable a individuosScany puede utilizar valores diferentes en


cualquier momento. Es posible que tenga que experimentar con estos valores y con el número de procesos
de trabajo utilizados hasta lograr el desempeño óptimo de la aplicación.
Note

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

Versión de API 2012-08-10


521
Amazon DynamoDB Guía para desarrolladores
Examen: Java

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.

Examen de tablas e índices: Java


LaScanLa operación lee todos los elementos de una tabla o un índice de Amazon DynamoDB.

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.

1. Cree una instancia de la clase AmazonDynamoDB.


2. Cree una instancia de la clase ScanRequest y proporcione el parámetro de examen.

El único parámetro obligatorio es el nombre de la tabla.


3. Ejecute lascany proporcionar el métodoScanRequestObjeto que creó en el paso anterior.

Los siguientes ejemplos deReplyLa tabla almacena las respuestas de las conversaciones del foro.

Example

Reply ( Id, ReplyDateTime, Message, PostedBy )

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

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();

ScanRequest scanRequest = new ScanRequest()


.withTableName("Reply");

ScanResult result = client.scan(scanRequest);


for (Map<String, AttributeValue> item : result.getItems()){
printItem(item);
}

Especificación de parámetros opcionales


El método scan admite varios parámetros opcionales. Por ejemplo, si lo desea puede utilizar una
expresión de filtro para filtrar el resultado del examen. En una expresión de filtro, puede especificar una
condición, así como los nombres y valores de atributos respecto a los que debe evaluarse esa condición.
Para obtener más información, consulteScan.

En el siguiente ejemplo de Java se examina elProductCatalogPara buscar elementos cuyo precio es


menor que 0. En el ejemplo se especifican los parámetros opcionales siguientes:

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

Versión de API 2012-08-10


522
Amazon DynamoDB Guía para desarrolladores
Examen: Java

Example

Map<String, AttributeValue> expressionAttributeValues =


new HashMap<String, AttributeValue>();
expressionAttributeValues.put(":val", new AttributeValue().withN("0"));

ScanRequest scanRequest = new ScanRequest()


.withTableName("ProductCatalog")
.withFilterExpression("Price < :val")
.withProjectionExpression("Id")
.withExpressionAttributeValues(expressionAttributeValues);

ScanResult result = client.scan(scanRequest);


for (Map<String, AttributeValue> item : result.getItems()) {
printItem(item);
}

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.

En el siguiente ejemplo de código Java se examina elProductCatalogTabla INTO. En la solicitud,


elwithLimitywithExclusiveStartKeyse utilizan métodos. El bucle do/while continúa examinando
una página cada vez hasta que el método getLastEvaluatedKey del resultado devuelve el valor null.

Example

Map<String, AttributeValue> lastKeyEvaluated = null;


do {
ScanRequest scanRequest = new ScanRequest()
.withTableName("ProductCatalog")
.withLimit(10)
.withExclusiveStartKey(lastKeyEvaluated);

ScanResult result = client.scan(scanRequest);


for (Map<String, AttributeValue> item : result.getItems()){
printItem(item);
}
lastKeyEvaluated = result.getLastEvaluatedKey();
} while (lastKeyEvaluated != null);

Ejemplo: Examen mediante Java


En el siguiente ejemplo de código Java se utiliza una muestra de trabajo que examina
elProductCatalogPara buscar elementos cuyo precio es menor que 100.
Note

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

Versión de API 2012-08-10


523
Amazon DynamoDB Guía para desarrolladores
Examen: Java

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;

public class DocumentAPIScan {

static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


static DynamoDB dynamoDB = new DynamoDB(client);
static String tableName = "ProductCatalog";

public static void main(String[] args) throws Exception {

findProductsForPriceLessThanOneHundred();
}

private static void findProductsForPriceLessThanOneHundred() {

Table table = dynamoDB.getTable(tableName);

Map<String, Object> expressionAttributeValues = new HashMap<String, Object>();


expressionAttributeValues.put(":pr", 100);

ItemCollection<ScanOutcome> items = table.scan("Price < :pr", // FilterExpression


"Id, Title, ProductCategory, Price", // ProjectionExpression
null, // ExpressionAttributeNames - not used in this example
expressionAttributeValues);

System.out.println("Scan of " + tableName + " for items with a price less than
100.");
Iterator<Item> iterator = items.iterator();
while (iterator.hasNext()) {

Versión de API 2012-08-10


524
Amazon DynamoDB Guía para desarrolladores
Examen: Java

System.out.println(iterator.next().toJSONPretty());
}
}

Ejemplo: Examen en paralelo mediante Java


En el siguiente ejemplo de código Java se muestra un examen en paralelo. El programa elimina y vuelve a
crear una tabla denominadaParallelScanTesty, a continuación, carga datos en ella. Una vez finalizada
la carga de datos, el programa crea varios subprocesos y emite en paraleloScansolicitudes. El programa
imprime estadísticas de tiempo de ejecución para cada solicitud en paralelo.
Note

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;

Versión de API 2012-08-10


525
Amazon DynamoDB Guía para desarrolladores
Examen: Java

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;

public class DocumentAPIParallelScan {

// total number of sample items


static int scanItemCount = 300;

// number of items each scan request should return


static int scanItemLimit = 10;

// number of logical segments for parallel scan


static int parallelScanThreads = 16;

// table that will be used for scanning


static String parallelScanTestTableName = "ParallelScanTest";

static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


static DynamoDB dynamoDB = new DynamoDB(client);

public static void main(String[] args) throws Exception {


try {

// Clean up the table


deleteTable(parallelScanTestTableName);
createTable(parallelScanTestTableName, 10L, 5L, "Id", "N");

// Upload sample data for scan


uploadSampleProducts(parallelScanTestTableName, scanItemCount);

// Scan the table using multiple threads


parallelScan(parallelScanTestTableName, scanItemLimit, parallelScanThreads);
}
catch (AmazonServiceException ase) {
System.err.println(ase.getMessage());
}
}

private static void parallelScan(String tableName, int itemLimit, int numberOfThreads)


{
System.out.println(
"Scanning " + tableName + " using " + numberOfThreads + " threads " + itemLimit
+ " items at a time");
ExecutorService executor = Executors.newFixedThreadPool(numberOfThreads);

// Divide DynamoDB table into logical segments


// Create one task for scanning each segment
// Each thread will be scanning one segment
int totalSegments = numberOfThreads;
for (int segment = 0; segment < totalSegments; segment++) {
// Runnable task that will only scan one segment
ScanSegmentTask task = new ScanSegmentTask(tableName, itemLimit, totalSegments,
segment);

// Execute the task


executor.execute(task);
}

shutDownExecutorService(executor);
}

// Runnable task for scanning a single segment of a DynamoDB table

Versión de API 2012-08-10


526
Amazon DynamoDB Guía para desarrolladores
Examen: Java

private static class ScanSegmentTask implements Runnable {

// DynamoDB table to scan


private String tableName;

// number of items each scan request should return


private int itemLimit;

// Total number of segments


// Equals to total number of threads scanning the table in parallel
private int totalSegments;

// Segment that will be scanned with by this task


private int segment;

public ScanSegmentTask(String tableName, int itemLimit, int totalSegments, int


segment) {
this.tableName = tableName;
this.itemLimit = itemLimit;
this.totalSegments = totalSegments;
this.segment = segment;
}

@Override
public void run() {
System.out.println("Scanning " + tableName + " segment " + segment + " out of "
+ totalSegments
+ " segments " + itemLimit + " items at a time...");
int totalScannedItemCount = 0;

Table table = dynamoDB.getTable(tableName);

try {
ScanSpec spec = new
ScanSpec().withMaxResultSize(itemLimit).withTotalSegments(totalSegments)
.withSegment(segment);

ItemCollection<ScanOutcome> items = table.scan(spec);


Iterator<Item> iterator = items.iterator();

Item currentItem = null;


while (iterator.hasNext()) {
totalScannedItemCount++;
currentItem = iterator.next();
System.out.println(currentItem.toString());
}

}
catch (Exception e) {
System.err.println(e.getMessage());
}
finally {
System.out.println("Scanned " + totalScannedItemCount + " items from
segment " + segment + " out of "
+ totalSegments + " of " + tableName);
}
}
}

private static void uploadSampleProducts(String tableName, int itemCount) {


System.out.println("Adding " + itemCount + " sample items to " + tableName);
for (int productIndex = 0; productIndex < itemCount; productIndex++) {
uploadProduct(tableName, productIndex);
}
}

Versión de API 2012-08-10


527
Amazon DynamoDB Guía para desarrolladores
Examen: Java

private static void uploadProduct(String tableName, int productIndex) {

Table table = dynamoDB.getTable(tableName);

try {
System.out.println("Processing record #" + productIndex);

Item item = new Item().withPrimaryKey("Id", productIndex)


.withString("Title", "Book " + productIndex + " Title").withString("ISBN",
"111-1111111111")
.withStringSet("Authors", new
HashSet<String>(Arrays.asList("Author1"))).withNumber("Price", 2)
.withString("Dimensions", "8.5 x 11.0 x 0.5").withNumber("PageCount", 500)
.withBoolean("InPublication", true).withString("ProductCategory", "Book");
table.putItem(item);

}
catch (Exception e) {
System.err.println("Failed to create item " + productIndex + " in " +
tableName);
System.err.println(e.getMessage());
}
}

private static void deleteTable(String tableName) {


try {

Table table = dynamoDB.getTable(tableName);


table.delete();
System.out.println("Waiting for " + tableName + " to be deleted...this may take
a while...");
table.waitForDelete();

}
catch (Exception e) {
System.err.println("Failed to delete table " + tableName);
e.printStackTrace(System.err);
}
}

private static void createTable(String tableName, long readCapacityUnits, long


writeCapacityUnits,
String partitionKeyName, String partitionKeyType) {

createTable(tableName, readCapacityUnits, writeCapacityUnits, partitionKeyName,


partitionKeyType, null, null);
}

private static void createTable(String tableName, long readCapacityUnits, long


writeCapacityUnits,
String partitionKeyName, String partitionKeyType, String sortKeyName, String
sortKeyType) {

try {
System.out.println("Creating table " + tableName);

List<KeySchemaElement> keySchema = new ArrayList<KeySchemaElement>();


keySchema.add(new
KeySchemaElement().withAttributeName(partitionKeyName).withKeyType(KeyType.HASH)); //
Partition

// key

List<AttributeDefinition> attributeDefinitions = new


ArrayList<AttributeDefinition>();
attributeDefinitions

Versión de API 2012-08-10


528
Amazon DynamoDB Guía para desarrolladores
Examen: .NET

.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));
}

Table table = dynamoDB.createTable(tableName, keySchema, attributeDefinitions,


new ProvisionedThroughput()

.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);
}
}

private static void shutDownExecutorService(ExecutorService executor) {


executor.shutdown();
try {
if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
executor.shutdownNow();
}
}
catch (InterruptedException e) {
executor.shutdownNow();

// Preserve interrupt status


Thread.currentThread().interrupt();
}
}
}

Examen de tablas e índices: .NET


LaScanLa operación lee todos los elementos de una tabla o un índice de Amazon DynamoDB.

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

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree una instancia de la clase ScanRequest y proporcione los parámetros de la operación de
examen.

El único parámetro obligatorio es el nombre de la tabla.


3. Ejecute laScany proporcionar el métodoQueryRequestObjeto que creó en el paso anterior.

Los siguientes ejemplos deReplyLa tabla almacena las respuestas de las conversaciones del foro.

Versión de API 2012-08-10


529
Amazon DynamoDB Guía para desarrolladores
Examen: .NET

Example

>Reply ( <emphasis role="underline">Id</emphasis>, <emphasis


role="underline">ReplyDateTime</emphasis>, Message, PostedBy )

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

AmazonDynamoDBClient client = new AmazonDynamoDBClient();

var request = new ScanRequest


{
TableName = "Reply",
};

var response = client.Scan(request);


var result = response.ScanResult;

foreach (Dictionary<string, AttributeValue> item in response.ScanResult.Items)


{
// Process the result.
PrintItem(item);
}

Especificación de parámetros opcionales

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.

En el siguiente ejemplo de C# se examina elProductCatalogPara buscar todos los elementos cuyo


precio es menor que 0.

Example

var forumScanRequest = new ScanRequest


{
TableName = "ProductCatalog",
// Optional parameters.
ExpressionAttributeValues = new Dictionary<string,AttributeValue> {
{":val", new AttributeValue { N = "0" }}
},
FilterExpression = "Price < :val",
ProjectionExpression = "Id"

Versión de API 2012-08-10


530
Amazon DynamoDB Guía para desarrolladores
Examen: .NET

};

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.

En el siguiente ejemplo de código C# se examina elProductCatalogTabla INTO. En la solicitud, se


especifican los parámetros opcionales Limit y ExclusiveStartKey. El bucle do/while continúa
examinando una página cada vez hasta que LastEvaluatedKey devuelve el valor null.

Example

Dictionary<string, AttributeValue> lastKeyEvaluated = null;


do
{
var request = new ScanRequest
{
TableName = "ProductCatalog",
Limit = 10,
ExclusiveStartKey = lastKeyEvaluated
};

var response = client.Scan(request);

foreach (Dictionary<string, AttributeValue> item


in response.Items)
{
PrintItem(item);
}
lastKeyEvaluated = response.LastEvaluatedKey;

} while (lastKeyEvaluated != null && lastKeyEvaluated.Count != 0);

Ejemplo: Examen mediante .NET


El siguiente código de C # proporciona un ejemplo de trabajo que escanea elProductCatalogPara
buscar elementos cuyo precio es menor que 0.

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;

Versión de API 2012-08-10


531
Amazon DynamoDB Guía para desarrolladores
Examen: .NET

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

static void Main(string[] args)


{
try
{
FindProductsForPriceLessThanZero();

Console.WriteLine("Example complete. To continue, press Enter");


Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
}

private static void FindProductsForPriceLessThanZero()


{
Dictionary<string, AttributeValue> lastKeyEvaluated = null;
do
{
var request = new ScanRequest
{
TableName = "ProductCatalog",
Limit = 2,
ExclusiveStartKey = lastKeyEvaluated,
ExpressionAttributeValues = new Dictionary<string, AttributeValue> {
{":val", new AttributeValue {
N = "0"
}}
},
FilterExpression = "Price < :val",

ProjectionExpression = "Id, Title, Price"


};

var response = client.Scan(request);

foreach (Dictionary<string, AttributeValue> item


in response.Items)
{
Console.WriteLine("\nScanThreadTableUsePaging - printing.....");
PrintItem(item);
}
lastKeyEvaluated = response.LastEvaluatedKey;
} while (lastKeyEvaluated != null && lastKeyEvaluated.Count != 0);

Console.WriteLine("To continue, press Enter");


Console.ReadLine();
}

private static void PrintItem(


Dictionary<string, AttributeValue> attributeList)
{

Versión de API 2012-08-10


532
Amazon DynamoDB Guía para desarrolladores
Examen: .NET

foreach (KeyValuePair<string, AttributeValue> kvp in attributeList)


{
string attributeName = kvp.Key;
AttributeValue value = kvp.Value;

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("************************************************");
}
}
}

Ejemplo: Examen en paralelo mediante .NET


En el siguiente ejemplo de código C# se muestra un examen en paralelo. El programa elimina y vuelve a
crear elProductCatalogy, a continuación, carga datos en ella. Una vez finalizada la carga de datos, el
programa crea varios subprocesos y emite en paraleloScansolicitudes. Por último, el programa imprime un
resumen de las estadísticas en tiempo de ejecución.

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;

Versión de API 2012-08-10


533
Amazon DynamoDB Guía para desarrolladores
Examen: .NET

static void Main(string[] args)


{
try
{
DeleteExampleTable();
CreateExampleTable();
UploadExampleData();
ParallelScanExampleTable();
}
catch (AmazonDynamoDBException e) { Console.WriteLine(e.Message); }
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }

Console.WriteLine("To continue, press Enter");


Console.ReadLine();
}

private static void ParallelScanExampleTable()


{
Console.WriteLine("\n*** Creating {0} Parallel Scan Tasks to scan {1}",
totalSegments, tableName);
Task[] tasks = new Task[totalSegments];
for (int segment = 0; segment < totalSegments; segment++)
{
int tmpSegment = segment;
Task task = Task.Factory.StartNew(() =>
{
ScanSegment(totalSegments, tmpSegment);
});

tasks[segment] = task;
}

Console.WriteLine("All scan tasks are created, waiting for them to complete.");


Task.WaitAll(tasks);

Console.WriteLine("All scan tasks are completed.");


}

private static void ScanSegment(int totalSegments, int segment)


{
Console.WriteLine("*** Starting to Scan Segment {0} of {1} out of {2} total
segments ***", segment, tableName, totalSegments);
Dictionary<string, AttributeValue> lastEvaluatedKey = null;
int totalScannedItemCount = 0;
int totalScanRequestCount = 0;
do
{
var request = new ScanRequest
{
TableName = tableName,
Limit = scanItemLimit,
ExclusiveStartKey = lastEvaluatedKey,
Segment = segment,
TotalSegments = totalSegments
};

var response = client.Scan(request);


lastEvaluatedKey = response.LastEvaluatedKey;
totalScanRequestCount++;
totalScannedItemCount += response.ScannedCount;
foreach (var item in response.Items)
{
Console.WriteLine("Segment: {0}, Scanned Item with Title: {1}",
segment, item["Title"].S);
}

Versión de API 2012-08-10


534
Amazon DynamoDB Guía para desarrolladores
Examen: .NET

} while (lastEvaluatedKey.Count != 0);

Console.WriteLine("*** Completed Scan Segment {0} of {1}.


TotalScanRequestCount: {2}, TotalScannedItemCount: {3} ***", segment, tableName,
totalScanRequestCount, totalScannedItemCount);
}

private static void UploadExampleData()


{
Console.WriteLine("\n*** Uploading {0} Example Items to {1} Table***",
exampleItemCount, tableName);
Console.Write("Uploading Items: ");
for (int itemIndex = 0; itemIndex < exampleItemCount; itemIndex++)
{
Console.Write("{0}, ", itemIndex);
CreateItem(itemIndex.ToString());
}
Console.WriteLine();
}

private static void CreateItem(string itemIndex)


{
var request = new PutItemRequest
{
TableName = tableName,
Item = new Dictionary<string, AttributeValue>()
{
{ "Id", new AttributeValue {
N = itemIndex
}},
{ "Title", new AttributeValue {
S = "Book " + itemIndex + " Title"
}},
{ "ISBN", new AttributeValue {
S = "11-11-11-11"
}},
{ "Authors", new AttributeValue {
SS = new List<string>{"Author1", "Author2" }
}},
{ "Price", new AttributeValue {
N = "20.00"
}},
{ "Dimensions", new AttributeValue {
S = "8.5x11.0x.75"
}},
{ "InPublication", new AttributeValue {
BOOL = false
} }
}
};
client.PutItem(request);
}

private static void CreateExampleTable()


{
Console.WriteLine("\n*** Creating {0} Table ***", tableName);
var request = new CreateTableRequest
{
AttributeDefinitions = new List<AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = "N"
}
},

Versión de API 2012-08-10


535
Amazon DynamoDB Guía para desarrolladores
Examen: .NET

KeySchema = new List<KeySchemaElement>


{
new KeySchemaElement
{
AttributeName = "Id",
KeyType = "HASH" //Partition key
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 5,
WriteCapacityUnits = 6
},
TableName = tableName
};

var response = client.CreateTable(request);

var result = response;


var tableDescription = result.TableDescription;
Console.WriteLine("{1}: {0} \t ReadsPerSec: {2} \t WritesPerSec: {3}",
tableDescription.TableStatus,
tableDescription.TableName,
tableDescription.ProvisionedThroughput.ReadCapacityUnits,
tableDescription.ProvisionedThroughput.WriteCapacityUnits);

string status = tableDescription.TableStatus;


Console.WriteLine(tableName + " - " + status);

WaitUntilTableReady(tableName);
}

private static void DeleteExampleTable()


{
try
{
Console.WriteLine("\n*** Deleting {0} Table ***", tableName);
var request = new DeleteTableRequest
{
TableName = tableName
};

var response = client.DeleteTable(request);


var result = response;
Console.WriteLine("{0} is being deleted...", tableName);
WaitUntilTableDeleted(tableName);
}
catch (ResourceNotFoundException)
{
Console.WriteLine("{0} Table delete failed: Table does not exist",
tableName);
}
}

private static void WaitUntilTableReady(string tableName)


{
string status = null;
// Let us wait until table is created. Call DescribeTable.
do
{
System.Threading.Thread.Sleep(5000); // Wait 5 seconds.
try
{
var res = client.DescribeTable(new DescribeTableRequest
{
TableName = tableName

Versión de API 2012-08-10


536
Amazon DynamoDB Guía para desarrolladores
Trabajar con el lenguaje de consulta PartiQL

});

Console.WriteLine("Table name: {0}, status: {1}",


res.Table.TableName,
res.Table.TableStatus);
status = res.Table.TableStatus;
}
catch (ResourceNotFoundException)
{
// DescribeTable is eventually consistent. So you might
// get resource not found. So we handle the potential exception.
}
} while (status != "ACTIVE");
}

private static void WaitUntilTableDeleted(string tableName)


{
string status = null;
// Let us wait until table is deleted. Call DescribeTable.
do
{
System.Threading.Thread.Sleep(5000); // Wait 5 seconds.
try
{
var res = client.DescribeTable(new DescribeTableRequest
{
TableName = tableName
});

Console.WriteLine("Table name: {0}, status: {1}",


res.Table.TableName,
res.Table.TableStatus);
status = res.Table.TableStatus;
}
catch (ResourceNotFoundException)
{
Console.WriteLine("Table name: {0} is not found. It is deleted",
tableName);
return;
}
} while (status == "DELETING");
}
}
}

PartiQL: un lenguaje de consulta compatible con


SQL para Amazon DynamoDB
Amazon DynamoDB admitePartiQL, un lenguaje de consulta compatible con SQL, para seleccionar,
insertar, actualizar y eliminar datos en Amazon DynamoDB. Utilizando PartiQL, puede interactuar
fácilmente con tablas de DynamoDB y ejecutar consultas ad hoc utilizando la herramientaAWS
Management Console, NoSQL Workbench,AWS Command Line Interfacey las API de DynamoDB para
PartiQL.

Las operaciones PartiQL proporcionan la misma disponibilidad, latencia y rendimiento que las demás
operaciones del plano de datos de DynamoDB.

En las siguientes secciones se describe la implementación de DynamoDB de PartiQL.

Temas

Versión de API 2012-08-10


537
Amazon DynamoDB Guía para desarrolladores
¿Qué es PartiQL?

• ¿Qué es PartiQL? (p. 538)


• PartiQL en Amazon DynamoDB (p. 538)
• Introducción a PartiQL para DynamoDB (p. 538)
• Tipos de datos de PartiQL para DynamoDB (p. 544)
• Instrucciones de PartiQL para DynamoDB (p. 546)
• Uso de funciones PartiQL con Amazon DynamoDB (p. 553)
• Operadores aritméticos, comparativos y lógicos de PartiQL para DynamoDB (p. 557)
• Realización de transacciones con PartiQL para DynamoDB (p. 558)
• Ejecución de operaciones Batch con PartiQL para DynamoDB (p. 561)
• Directivas de seguridad de IAM con PartiQL para DynamoDB (p. 564)

¿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

• Amazon DynamoDB admite unsubconjuntode laPartiQLlenguaje de consulta.


• Amazon DynamoDB no admite elAmazon Iono literales de Amazon Ion.

PartiQL en Amazon DynamoDB


Para ejecutar consultas PartiQL en DynamoDB, puede utilizar:

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

Introducción a PartiQL para DynamoDB


En esta sección se describe cómo utilizar PartiQL para DynamoDB desde la consola de Amazon
DynamoDB, laAWS Command Line Interface(AWS CLI) y las API de DynamoDB.

En los ejemplos siguientes, la tabla DynamoDB definida en el cuadro deIntroducción a DynamoDBEl


tutorial es un requisito previo.

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.

Paradescargary useNoSQL WorkbenchPara crearPartiQL para DynamoDBInstrucciones


ElegirOperaciones PartiQLEn la esquina superior derecha del área de trabajo NoSQL para
DynamoDBGenerador de operaciones.

Versión de API 2012-08-10


538
Amazon DynamoDB Guía para desarrolladores
Introducción

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.

1. Inicie sesión enAWS Management Consoley abra la consola de DynamoDB enhttps://


console.aws.amazon.com/dynamodb/.
2. En el panel de navegación del lado izquierdo de la consola, elijaEditor de PartiQL.
3. Elija el iconoMúsicaTabla INTO
4. SeleccionarTabla de consulta. Esta acción genera una consulta que no dará como resultado un
análisis de tabla completo.
5. ReemplazarpartitionKeyValuecon el valor de la cadenaAcme Band.
ReemplazarsortKeyValuecon el valor de la cadenaHappy Day.
6. Seleccione el botón Run (Ejecutar).
7. Puede ver los resultados de la consulta seleccionando la opciónVista de tablao elVista
JSONBotones .

Versión de API 2012-08-10


539
Amazon DynamoDB Guía para desarrolladores
Introducción

NoSQL Workbench

1. SeleccionarInstrucción PartiQL.
2. Introduzca la siguiente PartiQLInstrucción de selección

SELECT *
FROM Music
WHERE Artist=? and SongTitle=?

3. Para especificar un valor para la propiedadArtistySongTitleParámetros:

a. SeleccionarParámetros de solicitudes opcionales.


b. SeleccionarAñadir nuevos parámetros.
c. Elegir el tipo de atributocadenaValor ANDAcme Band.
d. Repita los pasos b y c y elija el tipocadenaValor ANDPartiQL Rocks.
4. Si desea generar código, seleccione Generate code (Generar código).

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

1. Cree un elemento en laMusicutilizando la instrucción INSERT PartiQL.

aws dynamodb execute-statement --statement "INSERT INTO Music \


VALUE \
{'Artist':'Acme Band','SongTitle':'PartiQL Rocks'}"

2. Recuperar un elemento de la tabla Música mediante la instrucción SELECT PartiQL.

aws dynamodb execute-statement --statement "SELECT * FROM Music \

Versión de API 2012-08-10


540
Amazon DynamoDB Guía para desarrolladores
Introducción

WHERE Artist='Acme Band' AND


SongTitle='PartiQL Rocks'"

3. Actualice un elemento en laMusicusando la instrucción UPDATE PartiQL.

aws dynamodb execute-statement --statement "UPDATE Music \


SET AwardsWon=1 \
SET AwardDetail={'Grammys':[2020,
2018]} \
WHERE Artist='Acme Band' AND
SongTitle='PartiQL Rocks'"

Agregue un valor de lista para un elemento en el cuadro de diálogoMusicTabla INTO

aws dynamodb execute-statement --statement "UPDATE Music \


SET AwardDetail.Grammys
=list_append(AwardDetail.Grammys,[2016]) \
WHERE Artist='Acme Band' AND
SongTitle='PartiQL Rocks'"

Quitar un valor de lista para un elemento en el cuadro de diálogoMusicTabla INTO

aws dynamodb execute-statement --statement "UPDATE Music \


REMOVE AwardDetail.Grammys[2] \
WHERE Artist='Acme Band' AND
SongTitle='PartiQL Rocks'"

Agregue un nuevo miembro de mapa para un elemento en el cuadro de diálogoMusicTabla INTO

aws dynamodb execute-statement --statement "UPDATE Music \


SET AwardDetail.BillBoard=[2020] \
WHERE Artist='Acme Band' AND
SongTitle='PartiQL Rocks'"

Agregue un nuevo atributo de conjunto de cadenas para un elemento en el cuadro de


diálogoMusicTabla INTO

aws dynamodb execute-statement --statement "UPDATE Music \


SET BandMembers =<<'member1',
'member2'>> \
WHERE Artist='Acme Band' AND
SongTitle='PartiQL Rocks'"

Actualice un atributo de conjunto de cadenas para un elemento en el cuadro de


diálogoMusicTabla INTO

aws dynamodb execute-statement --statement "UPDATE Music \


SET BandMembers =set_add(BandMembers,
<<'newmember'>>) \
WHERE Artist='Acme Band' AND
SongTitle='PartiQL Rocks'"

4. Eliminación de un elemento de la.Musicmediante la instrucción DELETE PartiQL.

aws dynamodb execute-statement --statement "DELETE FROM Music \


WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"

Versión de API 2012-08-10


541
Amazon DynamoDB Guía para desarrolladores
Introducción

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;

public class DynamoDBPartiQGettingStarted {

public static void main(String[] args) {


// Create the DynamoDB Client with the region you want
AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-1");

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 list value for an item in the Music table.


processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET
AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) where Artist=? and
SongTitle=?", parameters));

//Remove a list value for an item in the Music table.


processResults(executeStatementRequest(dynamoDB, "UPDATE Music REMOVE
AwardDetail.Grammys[2] where Artist=? and SongTitle=?", parameters));

//Add a new map member for an item in the Music table.


processResults(executeStatementRequest(dynamoDB, "UPDATE Music set
AwardDetail.BillBoard=[2020] 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));

//update a string set attribute for an item in the Music table.

Versión de API 2012-08-10


542
Amazon DynamoDB Guía para desarrolladores
Introducción

processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET


BandMembers =set_add(BandMembers, <<'newmember'>>) 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));

//delete an item from the Music Table


processResults(executeStatementRequest(dynamoDB, "DELETE FROM Music where
Artist=? and SongTitle=?", parameters));
} catch (Exception e) {
handleExecuteStatementErrors(e);
}
}

private static AmazonDynamoDB createDynamoDbClient(String region) {


return AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
}

private static List<AttributeValue> getPartiQLParameters() {


List<AttributeValue> parameters = new ArrayList<AttributeValue>();
parameters.add(new AttributeValue("Acme Band"));
parameters.add(new AttributeValue("PartiQL Rocks"));
return parameters;
}

private static ExecuteStatementResult executeStatementRequest(AmazonDynamoDB


client, String statement, List<AttributeValue> parameters ) {
ExecuteStatementRequest request = new ExecuteStatementRequest();
request.setStatement(statement);
request.setParameters(parameters);
return client.executeStatement(request);
}

private static void processResults(ExecuteStatementResult executeStatementResult) {


System.out.println("ExecuteStatement successful: "+
executeStatementResult.toString());

// Handles errors during ExecuteStatement execution. Use recommendations in error


messages below to add error handling specific to
// your application use-case.
private static void handleExecuteStatementErrors(Exception exception) {
try {
throw exception;
} catch (ConditionalCheckFailedException ccfe) {
System.out.println("Condition check specified in the operation failed,
review and update the condition " +
"check before retrying. Error: " +
ccfe.getErrorMessage());
} catch (TransactionConflictException tce) {
System.out.println("Operation was rejected because there is an ongoing
transaction for the item, generally " +
"safe to retry with exponential back-off. Error:
" + tce.getErrorMessage());
} catch (ItemCollectionSizeLimitExceededException icslee) {
System.out.println("An item collection is too large, you\'re using Local
Secondary Index and exceeded " +
"size limit of items per partition key. Consider
using Global Secondary Index instead. Error: " + icslee.getErrorMessage());
} catch (Exception e) {
handleCommonErrors(e);
}
}

Versión de API 2012-08-10


543
Amazon DynamoDB Guía para desarrolladores
Tipos de datos

private static void handleCommonErrors(Exception exception) {


try {
throw exception;
} catch (InternalServerErrorException isee) {
System.out.println("Internal Server Error, generally safe to retry with
exponential back-off. Error: " + isee.getErrorMessage());
} catch (RequestLimitExceededException rlee) {
System.out.println("Throughput exceeds the current throughput limit for
your account, increase account level throughput before " +
"retrying. Error: " + rlee.getErrorMessage());
} catch (ProvisionedThroughputExceededException ptee) {
System.out.println("Request rate is too high. If you're using a custom
retry strategy make sure to retry with exponential back-off. " +
"Otherwise consider reducing frequency of
requests or increasing provisioned capacity for your table or secondary index. Error:
" +
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());
}
}

Tipos de datos de PartiQL para DynamoDB


En la tabla siguiente se enumeran los tipos de datos que puede utilizar con PartiQL para DynamoDB.

Tipo de dato de DynamoDB Representación de PartiQL Notas

Boolean TRUE | FALSE No distingue entre mayúsculas

Binary N/A Sólo se admite a través de


código.

List [valor1, valor2,...] 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.

Versión de API 2012-08-10


544
Amazon DynamoDB Guía para desarrolladores
Tipos de datos

Tipo de dato de DynamoDB Representación de PartiQL Notas

Map {'nombre': valor} 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.

Null NULL No distingue entre mayúsculas

Number 1, 1.0, 1e0 Los números pueden ser


positivos, negativos o cero. Los
números pueden tener hasta
38 dígitos de precisión.

Number Set <number1, number2><> Los elementos de un conjunto


de números deben ser del tipo
Número.

String Set <<'cadena1', 'cadena2'>> Los elementos de un conjunto de


cadenas deben ser de tipo String.

String 'Valor de la cadena' Se deben usar comillas simples


para especificar valores String.

Examples
La instrucción siguiente muestra cómo insertar los siguientes tipos de
datos:String,Number,Map,List,Number SetyString Set.

INSERT INTO TypesTable value {'primarykey':'1',


'NumberType':1,
'MapType' : {'entryname1': 'value', 'entryname2': 4},
'ListType': [1,'stringval'],
'NumberSetType':<<1,34,32,4.5>>,
'StringSetType':<<'stringval','stringval2'>>
}

La siguiente instrucción muestra cómo insertar nuevos elementos en elMap,List,Number SetyString


SetTipos de valores y cambie el valor de unNumber.

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'

La siguiente instrucción muestra cómo eliminar elementos de laMap,List,Number SetyString


SetTipos de valores y cambie el valor de unNumber.

UPDATE TypesTable
SET NumberType=NumberType - 1
REMOVE ListType[1]
REMOVE MapType.NewMapEntry

Versión de API 2012-08-10


545
Amazon DynamoDB Guía para desarrolladores
Instrucciones

SET NumberSetType = SET_DELETE( NumberSetType, <<345>>)


SET StringSetType = SET_DELETE( StringSetType, <<'stringsetvalue1'>>)
WHERE primarykey='1'

Para obtener más información, consulteTipos de datos de DynamoDB.

Instrucciones de PartiQL para DynamoDB


Amazon DynamoDB admite las siguientes instrucciones PartiQL.
Note

DynamoDB no es compatible con todas las instrucciones PartiQL.


Esta referencia proporciona sintaxis básica y ejemplos de uso de sentencias PartiQL que se
ejecutan manualmente mediante el comandoAWS CLIAPI o API.

Lenguaje de manipulación de datos(DML) es el conjunto de instrucciones PartiQL que se utiliza para


administrar datos en tablas de DynamoDB. Puede utilizar instrucciones DML para agregar, modificar o
eliminar datos de una tabla.

Se admiten las siguientes instrucciones DML y lenguaje de consulta:

• Sentencias PartiQL Select para DynamoDB (p. 546)


• Declaraciones de actualización de PartiQL para DynamoDB (p. 549)
• Sentencias de inserción PartiQL para DynamoDB (p. 552)
• Sentencias de eliminación de PartiQL para DynamoDB (p. 551)

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.

Sentencias PartiQL Select para DynamoDB


UsarSELECTPara recuperar datos de una tabla de Amazon DynamoDB.

Mediante laSELECTpuede resultar en un análisis de tabla completo si no se proporciona una condición


de igualdad con una clave de partición en la cláusula WHERE. Una operación de análisis examina cada
elemento para comprobar si presenta los valores solicitados y permite utilizar el rendimiento provisionado
para una tabla o un índice grandes en una sola operación.

Si desea evitar el análisis completo de la tabla en PartiQL, puede:

• Genera tuSELECTpara que no resulten en exploraciones completas de la tabla asegurándose de que


suCondición de cláusula WHERSe configura en consecuencia.
• Deshabilite los análisis completos de tablas mediante la directiva de IAM especificada enEjemplo:
Permitir instrucciones Select y denegar instrucciones de análisis de tabla completa en PartiQL para
DynamoDB (p. 567), en la guía para desarrolladores de 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)

Versión de API 2012-08-10


546
Amazon DynamoDB Guía para desarrolladores
Instrucciones

Syntax

SELECT expression [, ...]


FROM table[.index]
[ WHERE condition ] [ [ORDER BY key [DESC|ASC] , ...]

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

(Necesario) Nombre de la tabla que se va a consultar.


índice

(Opcional) El nombre del índice que se consultará.


condición

(Opcional) Criterios de selección para la consulta.


Important

Para asegurarse de que unSELECTno da como resultado un análisis de tabla completo, la


instrucciónWHERELa condición de cláusula debe especificar una clave de partición. Utilice el
operador de igualdad o IN.
Por ejemplo, si tiene un valor de tipoOrderscon una tabla deOrderIDy otros atributos que
no son clave, incluido unAddress, las siguientes instrucciones no resultarían en un análisis
completo de la 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]

Los siguientes ejemplos deSELECT, sin embargo, resultarán en un análisis completo de la


tabla:

SELECT *
FROM Orders
WHERE OrderID > 1

SELECT *

Versión de API 2012-08-10


547
Amazon DynamoDB Guía para desarrolladores
Instrucciones

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

Si omite elWHERE, se recuperarán todos los elementos de la tabla.

Examples
La siguiente consulta devuelve un elemento, si existe, de laOrdersespecificando la clave de
partición,OrderIDy el uso del operador de igualdad.

SELECT OrderID, Total


FROM Orders
WHERE OrderID = 1

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.

SELECT OrderID, Total


FROM Orders
WHERE OrderID = 1 OR OrderID = 2

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.

SELECT OrderID, Total


FROM Orders
WHERE OrderID IN [1, 2, 3] ORDER BY OrderID DESC

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.

SELECT OrderID, Total


FROM Orders
WHERE Total > 500

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.

SELECT OrderID, Total


FROM Orders
WHERE Total IN [500, 600]

Versión de API 2012-08-10


548
Amazon DynamoDB Guía para desarrolladores
Instrucciones

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.

SELECT OrderID, Total


FROM Orders
WHERE Total BETWEEN 500 AND 600

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'

Declaraciones de actualización de PartiQL para DynamoDB


UsarUPDATEpara modificar el valor de uno o más atributos dentro de un elemento de una tabla de Amazon
DynamoDB.
Note

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

(Necesario) Tabla que contiene los datos que se van a modificar.

Versión de API 2012-08-10


549
Amazon DynamoDB Guía para desarrolladores
Instrucciones

path

(Necesario) Nombre de atributo o ruta de documento que se va a crear o modificar.


durante mucho tiempo

(Necesario) Valor de atributo o resultado de una operación.

Las operaciones admitidas para usar con SET:


• LIST_APPEND: añade un valor a un tipo de lista.
• SET_ADD: añade un valor a un número o conjunto de cadenas.
• SET_DELETE: elimina un valor de un número o conjunto de cadenas.
condición

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

La siguiente consulta actualiza un elemento de la.Musicagregando un atributo de tipo número


(AwardsWon) y un atributo de tipo map (AwardDetail).

UPDATE Music
SET AwardsWon=1
SET AwardDetail={'Grammys':[2020, 2018]}
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'

La siguiente consulta actualiza un elemento de la.Musicagregando a una listaAwardDetail.Grammys.

UPDATE Music

Versión de API 2012-08-10


550
Amazon DynamoDB Guía para desarrolladores
Instrucciones

SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016])


WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'

La siguiente consulta actualiza un elemento de la.Musiceliminando de una listaAwardDetail.Grammys.

UPDATE Music
REMOVE AwardDetail.Grammys[2]
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'

La siguiente consulta actualiza un elemento de la.Musictabla agregandoBillBoardMapa


INTOAwardDetail.

UPDATE Music
SET AwardDetail.BillBoard=[2020]
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'

La siguiente consulta actualiza un elemento de la.Musicagregando el atributo de conjunto de


cadenasBandMembers.

UPDATE Music
SET BandMembers =<<'member1', 'member2'>>
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'

La siguiente consulta actualiza un elemento de la.Musictabla agregandonewbandmemberal conjunto de


cadenasBandMembers.

UPDATE Music
SET BandMembers =set_add(BandMembers, <<'newbandmember'>>)
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'

Sentencias de eliminación de PartiQL para DynamoDB


UsarDELETEPara eliminar un elemento existente de la tabla de Amazon DynamoDB.
Note

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

DELETE FROM table


WHERE condition [RETURNING returnvalues]
<returnvalues> ::= ALL OLD *

Versión de API 2012-08-10


551
Amazon DynamoDB Guía para desarrolladores
Instrucciones

Parameters
tabla

(Obligatorio) La tabla de DynamoDB que contiene el elemento que se va a eliminar.


condición

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

Sentencias de inserción PartiQL para DynamoDB


UsarINSERTPara agregar un elemento a una tabla en Amazon DynamoDB.
Note

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.

INSERT INTO table VALUE item

Versión de API 2012-08-10


552
Amazon DynamoDB Guía para desarrolladores
Funciones

Parameters
tabla

(Obligatorio) La tabla en la que desea insertar los datos. La tabla debe existir previamente.
elemento

(Necesario) Un elemento válido de DynamoDB representado comoTupla PartiQL. Debe especificar


únicamenteoney cada nombre de atributo en el elemento distingue entre mayúsculas y minúsculas y
se puede denotar conSINGLEComillas ('...') en PartiQL.

Los valores de cadena también se denotan conSINGLEComillas ('...') en PartiQL.

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

Uso de funciones PartiQL con Amazon DynamoDB


PartiQL en Amazon DynamoDB admite las siguientes variantes integradas de funciones estándar de SQL.
Note

En DynamoDB no se admite ninguna función SQL que no se incluya en esta lista.

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)

Uso de la función EXISTS con PartiQL para DynamoDB


Puede usar EXISTS para realizar la misma función queConditionChecken laTransactWriteItemsAPI. La
función EXISTS sólo se puede utilizar en transacciones.

Dado un valor, devuelveTRUEsi el valor es una colección no vacía. De lo contrario, devuelve FALSE.

Versión de API 2012-08-10


553
Amazon DynamoDB Guía para desarrolladores
Funciones

Note

Esta función sólo se puede utilizar en operaciones transaccionales.

Syntax

EXISTS ( statement )

Arguments
statement

(Requerido) La instrucción SELECT que evalúa la función.


Note

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

Uso de la función BEGINS_WITH con PartiQL para DynamoDB


DevuelveTRUESi el atributo especificado comienza por una subcadena determinada.

Syntax

begins_with(path, value )

Arguments
path

(Necesario) Nombre del atributo o ruta del documento que se va a utilizar.


value

(Requerido) La cadena que se buscará.

Tipo de retorno
bool

Examples

SELECT * FROM "Orders" WHERE "OrderID"=1 AND begins_with("Address", '7834 24th')

Versión de API 2012-08-10


554
Amazon DynamoDB Guía para desarrolladores
Funciones

Uso de la función FISTING con PartiQL para DynamoDB


DevuelveTRUEsi el elemento no contiene el atributo especificado. Sólo los operadores de igualdad y
desigualdad pueden ser utilizados con esta función.

Syntax

attributename IS | IS NOT MISSING

Arguments
attributeName

(Necesario) Nombre del atributo que se va a buscar.

Tipo de retorno
bool

Examples

SELECT * FROM Music WHERE "Awards" is MISSING

Uso de la función ATTRIBUTE_TYPE con PartiQL para


DynamoDB
DevuelveTRUESi el atributo de la ruta especificada es de un tipo de datos determinado.

Syntax

attribute_type( attributename, type )

Arguments
attributeName

(Necesario) Nombre del atributo que se va a utilizar.


type

(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

SELECT * FROM "Music" WHERE attribute_type("Artist", 'S')

Versión de API 2012-08-10


555
Amazon DynamoDB Guía para desarrolladores
Funciones

Uso de la función CONTINS con PartiQL para DynamoDB


DevuelveTRUESi el atributo especificado por la ruta es uno de los siguientes:

• un valor de tipo String que contiene una determinada subcadena;


• Un valor de tipo Set que contiene una entrada determinada perteneciente al conjunto.

Para obtener más información, consulte el tema relacionado con DynamoDBcontienefunción.

Syntax

contains( path, substring )

Arguments
path

(Necesario) Nombre del atributo o ruta del documento que se va a utilizar.


subcadena

(Necesario) La subcadena de atributo o miembro de conjunto que se va a comprobar. Para obtener


más información, consulte el tema relacionado con DynamoDBcontienefunción.

Tipo de retorno
bool

Examples

SELECT * FROM "Orders" WHERE "OrderID"=1 AND contains("Address", 'Kirkland')

Uso de la función SIZE con PartiQL para Amazon DynamoDB


Devuelve un número que representa el tamaño de un atributo en bytes. A continuación se muestran
los tipos de datos válidos para usarlos con tamaño. Para obtener más información, consulte el tema
relacionado con DynamoDBsizefunción.

Syntax

size( path)

Arguments
path

(Necesario) Nombre del atributo o ruta del documento.

Para conocer los tipos admitidos, consulte DynamoDBsizefunción.

Tipo de retorno
int

Versión de API 2012-08-10


556
Amazon DynamoDB Guía para desarrolladores
Operadores

Examples

SELECT * FROM "Orders" WHERE "OrderID"=1 AND size("Image") >300

Operadores aritméticos, comparativos y lógicos de


PartiQL para DynamoDB
PartiQL en Amazon DynamoDB admite lo siguienteOperadores estándares de SQL estándar.
Note

En DynamoDB no se admite ningún operador SQL que no se incluya en esta lista.

Operadores aritméticos

"." Descripción

+ Add

- Subtract (Sustracción)

Operadores de comparación

"." Descripción

= Igual que

<> No igual que

> Mayor que

< Menor que

>= Mayor o igual que

<= Menor o igual que

Operadores lógicos

"." Descripción

AND TRUEsi todas las condiciones están separadas


porANDsonTRUE

BETWEEN TRUESi el operado se inscribe en el rango de


comparaciones

IN TRUEsi el operando es igual a una de una lista de


expresiones

IS TRUEsi el operando es un tipo de datos PartiQL


dado, incluyendoNULLorMISSING

Versión de API 2012-08-10


557
Amazon DynamoDB Guía para desarrolladores
Transacciones

"." Descripción

NOT Invierte el valor de una expresión booleana dada

OR TRUEsi alguna de las condiciones está separada


porORsonTRUE

Realización de transacciones con PartiQL para


DynamoDB
En esta sección se describe cómo utilizar transacciones con PartiQL para DynamoDB.

Para obtener más información acerca de las transacciones de DynamoDB, consulteAdministración de


flujos de trabajo complejos con transacciones de DynamoDB.
Note

Toda la transacción debe constar de sentencias de lectura o de escritura; no se pueden mezclar


ambas en una sola transacción. La función EXISTS es una excepción y se puede utilizar
para comprobar la condición de atributos específicos del elemento de una manera similar
aConditionChecken laTransactWriteItemsAPI.

Temas
• Syntax (p. 558)
• Parameters (p. 558)
• Valores de retorno (p. 559)
• Examples (p. 559)

Syntax
[
{
"Statement":" statement ",
"Parameters":[
{
" parametertype " : " parametervalue "
}, ...]
} , ...
]

Parameters
statement

(Necesario) Una instrucción compatible con PartiQL para DynamoDB.


Note

Toda la transacción debe constar de sentencias de lectura o de escritura; no se pueden


mezclar ambas en una sola transacción.
tipo de parámetro

(Opcional) Tipo DynamoDB, si se utilizaron parámetros al especificar la instrucción PartiQL.

Versión de API 2012-08-10


558
Amazon DynamoDB Guía para desarrolladores
Transacciones

ParameterValue

(Opcional) Valor de parámetro si se utilizaron parámetros al especificar la instrucción PartiQL.

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

1. Guarde el siguiente json en un archivo llamado partiql.json

[
{
"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'"
}
]

2. Ejecute el comando siguiente en un símbolo del sistema.

aws dynamodb execute-transaction --transact-statements file://partiql.json

Java

public class DynamoDBPartiqlTransaction {

public static void main(String[] args) {


// Create the DynamoDB Client with the region you want
AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-2");

try {
// Create ExecuteTransactionRequest
ExecuteTransactionRequest executeTransactionRequest =
createExecuteTransactionRequest();
ExecuteTransactionResult executeTransactionResult =
dynamoDB.executeTransaction(executeTransactionRequest);
System.out.println("ExecuteTransaction successful.");
// Handle executeTransactionResult

} catch (Exception e) {
handleExecuteTransactionErrors(e);
}

Versión de API 2012-08-10


559
Amazon DynamoDB Guía para desarrolladores
Transacciones

private static AmazonDynamoDB createDynamoDbClient(String region) {


return AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
}

private static ExecuteTransactionRequest createExecuteTransactionRequest() {


ExecuteTransactionRequest request = new ExecuteTransactionRequest();

// Create statements
List<ParameterizedStatement> statements = getPartiQLTransactionStatements();

request.setTransactStatements(statements);
return request;
}

private static List<ParameterizedStatement> getPartiQLTransactionStatements() {


List<ParameterizedStatement> statements = new
ArrayList<ParameterizedStatement>();

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;
}

// Handles errors during ExecuteTransaction execution. Use recommendations in error


messages below to add error handling specific to
// your application use-case.
private static void handleExecuteTransactionErrors(Exception exception) {
try {
throw exception;
} catch (TransactionCanceledException tce) {
System.out.println("Transaction Cancelled, implies a client issue, fix
before retrying. Error: " + tce.getErrorMessage());
} catch (TransactionInProgressException tipe) {
System.out.println("The transaction with the given request token is already
in progress, consider changing " +
"retry strategy for this type of error. Error: " +
tipe.getErrorMessage());
} catch (IdempotentParameterMismatchException ipme) {
System.out.println("Request rejected because it was retried with a
different payload but with a request token that was already used, " +
"change request token for this payload to be accepted. Error: " +
ipme.getErrorMessage());
} catch (Exception e) {
handleCommonErrors(e);
}
}

private static void handleCommonErrors(Exception exception) {


try {
throw exception;
} catch (InternalServerErrorException isee) {

Versión de API 2012-08-10


560
Amazon DynamoDB Guía para desarrolladores
Operaciones por lotes

System.out.println("Internal Server Error, generally safe to retry with


exponential back-off. Error: " + isee.getErrorMessage());
} catch (RequestLimitExceededException rlee) {
System.out.println("Throughput exceeds the current throughput limit for
your account, increase account level throughput before " +
"retrying. Error: " + rlee.getErrorMessage());
} catch (ProvisionedThroughputExceededException ptee) {
System.out.println("Request rate is too high. If you're using a custom
retry strategy make sure to retry with exponential back-off. " +
"Otherwise consider reducing frequency of requests or increasing
provisioned capacity for your table or secondary index. Error: " +
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());
}
}

Ejecución de operaciones Batch con PartiQL para


DynamoDB
En esta sección se describe cómo utilizar instrucciones por lotes con PartiQL para DynamoDB.
Note

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":[
{

Versión de API 2012-08-10


561
Amazon DynamoDB Guía para desarrolladores
Operaciones por lotes

" parametertype " : " parametervalue "


}, ...]
} , ...
]

Parameters
statement

(Necesario) Una instrucción compatible con PartiQL para DynamoDB.


Note

Todo el lote debe constar de sentencias de lectura o de escritura; no se pueden mezclar


ambas en un solo lote.
tipo de parámetro

(Opcional) Tipo DynamoDB, si se utilizaron parámetros al especificar la instrucción PartiQL.


ParameterValue

(Opcional) Valor de parámetro si se utilizaron parámetros al especificar la instrucción PartiQL.

Examples
AWS CLI

1. Guarde el siguiente json en un archivo llamado partiql.json

[
{
"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'"
}
]

2. Ejecute el comando siguiente en un símbolo del sistema.

aws dynamodb batch-execute-statement --statements file://partiql.json

Java

public class DynamoDBPartiqlBatch {

public static void main(String[] args) {


// Create the DynamoDB Client with the region you want
AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-2");

try {
// Create BatchExecuteStatementRequest
BatchExecuteStatementRequest batchExecuteStatementRequest =
createBatchExecuteStatementRequest();
BatchExecuteStatementResult batchExecuteStatementResult =
dynamoDB.batchExecuteStatement(batchExecuteStatementRequest);
System.out.println("BatchExecuteStatement successful.");

Versión de API 2012-08-10


562
Amazon DynamoDB Guía para desarrolladores
Operaciones por lotes

// Handle batchExecuteStatementResult

} catch (Exception e) {
handleBatchExecuteStatementErrors(e);
}
}

private static AmazonDynamoDB createDynamoDbClient(String region) {

return AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
}

private static BatchExecuteStatementRequest createBatchExecuteStatementRequest() {


BatchExecuteStatementRequest request = new BatchExecuteStatementRequest();

// Create statements
List<BatchStatementRequest> statements = getPartiQLBatchStatements();

request.setStatements(statements);
return request;
}

private static List<BatchStatementRequest> getPartiQLBatchStatements() {


List<BatchStatementRequest> statements = new
ArrayList<BatchStatementRequest>();

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;
}

// Handles errors during BatchExecuteStatement execution. Use recommendations in


error messages below to add error handling specific to
// your application use-case.
private static void handleBatchExecuteStatementErrors(Exception exception) {
try {
throw exception;
} catch (Exception e) {
// There are no API specific errors to handle for BatchExecuteStatement,
common DynamoDB API errors are handled below
handleCommonErrors(e);
}
}

private static void handleCommonErrors(Exception exception) {


try {
throw exception;
} catch (InternalServerErrorException isee) {
System.out.println("Internal Server Error, generally safe to retry with
exponential back-off. Error: " + isee.getErrorMessage());
} catch (RequestLimitExceededException rlee) {
System.out.println("Throughput exceeds the current throughput limit for
your account, increase account level throughput before " +
"retrying. Error: " + rlee.getErrorMessage());
} catch (ProvisionedThroughputExceededException ptee) {
System.out.println("Request rate is too high. If you're using a custom
retry strategy make sure to retry with exponential back-off. " +
"Otherwise consider reducing frequency of requests or increasing
provisioned capacity for your table or secondary index. Error: " +

Versión de API 2012-08-10


563
Amazon DynamoDB Guía para desarrolladores
Políticas de IAM

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

Directivas de seguridad de IAM con PartiQL para


DynamoDB
Los siguientes permisos son necesarios:

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

Ejemplo: Permitir todas las instrucciones PartiQL para


DynamoDB (Select/Insert/Update/Delete) en una tabla
La siguiente política de IAM concede permisos para ejecutar todas las instrucciones PartiQL para
DynamoDB en una tabla.

{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLInsert",
"dynamodb:PartiQLUpdate",
"dynamodb:PartiQLDelete",
"dynamodb:PartiQLSelect"
],

Versión de API 2012-08-10


564
Amazon DynamoDB Guía para desarrolladores
Políticas de IAM

"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
]
}
]
}

Ejemplo: Permitir instrucciones de selección de PartiQL para


DynamoDB en una tabla
La siguiente política de IAM concede permisos para ejecutar elselectDeclaración de una tabla específica.

{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
]
}
]
}

Ejemplo: Permitir instrucciones de inserción de PartiQL para


DynamoDB en un índice
La siguiente política de IAM concede permisos para ejecutar elinserten un índice específico.

{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLInsert"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music/index/index1"
]
}
]
}

Ejemplo: Permitir PartiQL para instrucciones transaccionales de


DynamoDB sólo en una tabla
La siguiente política de IAM concede permisos para ejecutar solamente sentencias transaccionales en una
tabla específica.

{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",

Versión de API 2012-08-10


565
Amazon DynamoDB Guía para desarrolladores
Políticas de IAM

"Action":[
"dynamodb:PartiQLInsert",
"dynamodb:PartiQLUpdate",
"dynamodb:PartiQLDelete",
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
],
"Condition":{
"StringEquals":{
"dynamodb:EnclosingOperation":[
"ExecuteTransaction"
]
}
}
}
]
}

Ejemplo: Permitir lecturas y escrituras no transaccionales


de PartiQL para DynamoDB y bloquear lecturas y escrituras
transaccionales de PartiQL en una tabla.
La siguiente directiva de IAM otorga permisos para ejecutar PartiQL para lecturas y escrituras no
transaccionales de DynamoDB mientras bloquea PartiQL para lecturas y escrituras transaccionales de
DynamoDB.

{
"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"
]
}

Versión de API 2012-08-10


566
Amazon DynamoDB Guía para desarrolladores
Uso de índices

]
}

Ejemplo: Permitir instrucciones Select y denegar instrucciones de


análisis de tabla completa en PartiQL para DynamoDB
La siguiente política de IAM concede permisos para ejecutar elselecten una tabla específica mientras se
bloqueaselectLas instrucciones que dan lugar a un examen completo de la tabla.

{
"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"
]
}
]
}

Uso de índices secundarios para mejorar el acceso


a los datos
Temas
• Uso de índices secundarios en DynamoDB (p. 570)
• Índices secundarios locales (p. 612)

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

Versión de API 2012-08-10


567
Amazon DynamoDB Guía para desarrolladores
Uso de índices

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.

DynamoDB admite dos tipos de índices secundarios:

• Í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.

Característica Índice secundario global Índice secundario local

Esquema de claves La clave principal de un índice La clave principal de un índice


secundario global puede ser secundario local debe ser
simple (clave de partición) o compuesta (clave de partición y
compuesta (clave de partición y clave de ordenación).
clave de ordenación).

Atributos de clave La clave de partición y la clave La clave de partición del índice


de ordenación (si procede) del es el mismo atributo que la clave
índice pueden ser cualesquiera de partición de la tabla base. La
atributos de tipo String, Number o clave de ordenación puede ser
Binary de la tabla base. cualquier atributo de tipo String,
Number o Binary de la tabla
base.

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.

Versión de API 2012-08-10


568
Amazon DynamoDB Guía para desarrolladores
Uso de índices

Característica Índice secundario global Índice secundario local

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

Consultas y particiones Un índice secundario global Un índice secundario local


permite realizar consultas en permite consultar una sola
toda la tabla y en todas las partición, según lo especificado
particiones. por el valor de clave de partición
de la consulta.

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.

Consumo de desempeño Cada índice secundario global Las consultas o exámenes


provisionado tiene sus propios ajustes de de un índice secundario
desempeño provisionado para la local consumen unidades de
actividad de lectura y escritura. capacidad de lectura de la tabla
Las consultas o exámenes base. Al escribir en una tabla,
de un índice secundario sus índices secundarios locales
global consumen unidades de también se actualizan y estas
capacidad del índice, no de la actualizaciones consumen
tabla base. Esto mismo sucede unidades de capacidad de
con las actualizaciones globales escritura de la tabla base.
del índice secundario debido a
escrituras en la tabla.

Atributos proyectados Cuando se consulta o examina Cuando se consulta o examina


un índice secundario global, solo un índice secundario local, se
se pueden solicitar los atributos pueden solicitar los atributos
que se han proyectado en él. que no se hayan proyectado
DynamoDB no obtiene ningún en él. DynamoDB recupera
atributo de la tabla. automáticamente estos atributos
de la tabla.

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.

Para cada índice secundario, debe especificar lo siguiente:

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

Versión de API 2012-08-10


569
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

• 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:

• AWSGovCloud UU. Este)


• AWSGovCloud (EE. UU. Oeste)
• Europe (Stockholm)

Para obtener un listado detallado de índices secundarios en una tabla, use


elDescribeTable.DescribeTabledevuelve el nombre, el tamaño de almacenamiento y el recuento
de elementos de cada índice secundario de la tabla. Estos valores no se actualizan en tiempo real, sino
aproximadamente cada seis horas.

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

Uso de índices secundarios en DynamoDB


Algunas aplicaciones pueden necesitar llevar a cabo muy diversos tipos de consultas en las que se
usen distintos atributos como criterios de consulta. Para responder a estos requisitos, puede crear un o
variosÍndices secundarios globales dey emitaQuerysolicitudes en relación con estos índices en Amazon
DynamoDB.

Temas
• ESCENARIO Uso de un índice secundario global (p. 571)
• Proyecciones de atributos (p. 574)

Versión de API 2012-08-10


570
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

• Lectura de datos de un índice secundario global (p. 576)


• Sincronización de datos entre tablas e índices secundarios globales (p. 576)
• Consideraciones sobre el desempeño provisionado para los índices secundarios globales (p. 577)
• Consideraciones sobre el almacenamiento para los índices secundarios globales (p. 578)
• Administración de índices secundarios globales (p. 579)
• Uso de índices secundarios: Java (p. 592)
• Uso de índices secundarios: .NET (p. 600)
• Trabajo con índices secundarios:AWS CLI (p. 610)

ESCENARIO Uso de un índice secundario global


Por poner un ejemplo, tomemos una tabla denominada GameScores que realiza el seguimiento de los
usuarios y las puntuaciones de una aplicación de juegos para móviles. Cada elemento en GameScores
se identifica por una clave de partición (UserId) y una clave de ordenación (GameTitle). En el siguiente
diagrama se muestra cómo se organizarían los elementos de la tabla. No se muestran todos los atributos.

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:

• ¿Cuál es la puntuación máxima que se ha registrado en el juego Meteor Blasters?


• ¿Qué usuario ha obtenido la mejor puntuación en Galaxy Invaders?
• ¿Cuál es la mayor proporción de partidas ganadas respecto a las perdidas?

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

Versión de API 2012-08-10


571
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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

Versión de API 2012-08-10


572
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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.

UserId GameTitle TopScore

123 Comet Quest 0

201 Comet Quest 0

301 Comet Quest 0

Cuando estos datos se agregan a laGameScores, DynamoDB lo propaga aGameTitleIndex. Si, a


continuación, consultamos el índice con el valor Comet Quest en GameTitle y el valor 0 en TopScore, se
devuelven los valores siguientes.

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

400 Comet Quest

Debido a que no especificó elTopScore, DynamoDB no propagará este elemento aGameTitleIndex.


Por lo tanto, si consultase GameScores para obtener todos los elementos de Comet Quest, obtendría los
siguientes cuatro elementos.

Versión de API 2012-08-10


573
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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.

En el diagrama anterior,GameTitleIndextiene solo un atributo proyectado: UserId. Por lo tanto, si


bien una aplicación puede determinar eficientemente elUserIdde los mejores goleadores de cada juego
usandoGameTitleyTopScoreEn las consultas, no puede determinar de manera eficiente la mayor
proporción de partidas ganadas respecto a las perdidas para los jugadores con mayor puntuación. Para
ello, tendría que realizar una consulta adicional en la tabla base para recuperar las partidas ganadas y
perdidas de cada uno de los jugadores con mayor puntuación. Una manera más eficiente de consultar
estos datos sería proyectar estos atributos de la tabla base en el índice secundario global, tal y como se
muestra en este diagrama.

Versión de API 2012-08-10


574
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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.

Versión de API 2012-08-10


575
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

Lectura de datos de un índice secundario global


Puede recuperar elementos de un índice secundario global mediante elQueryyScanOperaciones.
LaGetItemyGetBatchItemLas operaciones no se pueden utilizar en un índice secundario global.

Consulta de un índice secundario global


Puede utilizarQuerypara obtener acceso a uno o varios elementos de un índice secundario global. En la
consulta se 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 de la consulta y las condiciones de consulta que se van a
aplicar. DynamoDB puede devolver los resultados en orden ascendente o descendente.

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:

• Accesos de DynamoDBGameTitleIndex, mediante laGameTitlePara localizar los elementos del índice


correspondientes a Meteor Blasters. Todos los elementos de índice que tienen esta clave se almacenan
en posiciones adyacentes, para agilizar su recuperación.
• En este juego, DynamoDB utiliza el índice para obtener acceso a todos los identificadores de los
usuarios y a las puntuaciones máximas de este juego.
• Los resultados se devuelven ordenados por orden descendente, porque el parámetro
ScanIndexForward se ha establecido en false.

Análisis de un índice secundario global


Puede utilizarScanpara recuperar todos los datos de un índice secundario global. Debe proporcionar el
nombre de la tabla base y el nombre del índice en la solicitud. Con unScan, DynamoDB lee todos los datos
del índice y los devuelve a la aplicación. También puede solicitar que solo se devuelvan algunos de los
datos y se descarten los demás. Para ello, se utiliza el parámetro FilterExpression de la operación
Scan. Para obtener más información, consulte Expresiones de filtro para Scan (p. 516).

Sincronización de datos entre tablas e índices secundarios


globales
DynamoDB sincroniza automáticamente cada índice secundario global con su tabla base. Cuando una
aplicación escribe o elimina elementos en una tabla, los índices secundarios globales de esa tabla se
actualizan de forma asincrónica, aplicando un modelo de consistencia final. Las aplicaciones nunca
escriben directamente en un índice. Sin embargo, es importante comprender las implicaciones de cómo
DynamoDB mantiene estos índices.

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

Versión de API 2012-08-10


576
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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

Consideraciones sobre el desempeño provisionado para los


índices secundarios globales
Al crear un índice secundario global en una tabla de modo aprovisionado, debe especificar las unidades de
capacidad de lectura y escritura para la carga de trabajo prevista de ese índice. Los ajustes de desempeño
provisionado de un índice secundario global son independientes de los de su tabla base. AQueryUna
operación en un índice secundario global consume unidades de capacidad de lectura del índice, no de la
tabla base. Al colocar, actualizar o eliminar elementos en una tabla, sus índices secundarios globales se
actualizan de forma consistente final. Estas actualizaciones de índices consumen unidades de capacidad
de escritura del índice, no de la tabla base.

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.

Unidades de capacidad de lectura


Los índices secundarios globales admiten las lecturas consistentes finales, cada una de la cuales consume
la mitad de una unidad de capacidad de lectura. Esto quiere decir que una sola consulta global de índices
secundarios globales puede recuperar hasta 2 × 4 KB = 8 KB por unidad de capacidad de lectura.

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

Versión de API 2012-08-10


577
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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.

Unidades de capacidad de escritura


Cuando se agrega, actualiza o elimina un elemento de una tabla y esto afecta a un índice secundario
global, el índice secundario global consume unidades de capacidad de escritura provisionadas por
esta operación. El costo total de desempeño provisionado de una escritura es la suma de las unidades
de capacidad de escritura consumidas al escribir en la tabla base y aquellas consumidas al actualizar
los índices secundarios globales. Si una escritura en una tabla no requiere que se actualice un índice
secundario global, no se consume ninguna capacidad de escritura del índice.

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.

El costo de escribir un elemento en un índice secundario global depende de varios factores:

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

Consideraciones sobre el almacenamiento para los índices


secundarios globales
Cuando una aplicación escribe un elemento en una tabla, DynamoDB copia automáticamente el
subconjunto de atributos en todos los índices secundarios globales en los que deban aparecer esos

Versión de API 2012-08-10


578
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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.

La cantidad de espacio utilizado por un elemento de índice es la suma de lo siguiente:

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

Administración de índices secundarios globales


En esta sección se describe cómo crear, modificar y eliminar índices secundarios globales en Amazon
DynamoDB.

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)

Creación de una tabla con índices secundarios globales


Para crear una tabla con uno o varios índices secundarios globales, use la operación CreateTable con el
parámetro GlobalSecondaryIndexes. Para disfrutar de la máxima flexibilidad en las consultas, puede
crear hasta 20 índices secundarios globales (cuota predeterminada) por tabla.

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

Versión de API 2012-08-10


579
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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

Descripción de los índices secundarios globales en una tabla


Para ver el estado de todos los índices secundarios globales de una tabla, se usa la operación
DescribeTable. La parte GlobalSecondaryIndexes de la respuesta enumera todos los índices de la
tabla, junto con el estado actual de cada uno de ellos (IndexStatus).

LaIndexStatuspara un índice secundario global será uno de los siguientes:

• CREATING: el índice se está creando y aún no está disponible para usarlo.


• ACTIVE: el índice está listo para usarlo y las aplicaciones pueden realizar operaciones en
él.Queryoperaciones en el índice.
• UPDATING: se están cambiando los ajustes de desempeño provisionado del índice.
• DELETING: el índice se está eliminando y ya no se puede utilizar.

Cuando DynamoDB ha terminado de crear un índice secundario global, el estado de este último cambia
deCREATINGDe aACTIVE.

Agregar un índice secundario global a una tabla existente


Para agregar un índice secundario global a una tabla existente, utilice la
herramientaUpdateTableoperación con laGlobalSecondaryIndexUpdatesParámetro. Debe
proporcionar lo siguiente:

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

Solo puede crear un índice secundario global porUpdateTable.

Fases de creación de los índices


Al agregar un nuevo índice secundario global a una tabla existente, la tabla sigue estando disponible
mientras se crea el índice. Sin embargo, el nuevo índice no estará disponible para las operaciones de
consulta hasta que el estado cambie de CREATING a ACTIVE.

En segundo plano, DynamoDB crea el índice en dos fases:

Asignación de recursos

DynamoDB asigna los recursos de computación y almacenamiento que se necesitan para crear el
índice.

Versión de API 2012-08-10


580
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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.

Mientras el índice se encuentra en la fase de asignación de recursos, no se puede eliminar el índice ni


eliminar su tabla principal. Tampoco se puede modificar el rendimiento aprovisionado del índice ni de
la tabla. No se pueden agregar ni eliminar otros índices de la tabla. Sin embargo, se puede modificar
el rendimiento aprovisionado de estos otros índices.
Reposición

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.

Durante la fase de reposición, el atributo IndexStatus está establecido en CREATING y el atributo


Backfilling está establecido en true. Use la operación DescribeTable para recuperar el estado
de una tabla y todos sus índices secundarios.

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

Durante la fase de reposición, algunas escrituras de elementos infractores podrían realizarse


correctamente y otras se rechazarán. Después de la reposición, se rechazarán todas las
escrituras en elementos que infrinjan el esquema de claves del nuevo índice. Recomendamos
ejecutar la herramienta Detector de infracciones una vez que haya finalizado la fase
de reposición para detectar y resolver cualquier infracción de clave que pueda haberse
producido. Para obtener más información, consulte Detección y corrección de infracciones de
claves de índice (p. 583).

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

Versión de API 2012-08-10


581
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

Adición de un índice secundario global


El tiempo necesario para crear un índice secundario global depende de varios factores, tales como los
siguientes:

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

Eliminación de un índice secundario global


Si ya no necesita un índice secundario global, puede eliminarlo mediante elUpdateTable.

Solo puede eliminar un índice secundario global por cadaUpdateTable.

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.

Versión de API 2012-08-10


582
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

Note

Al eliminar una tabla mediante la acción DeleteTable, todos los índices secundarios globales de
esa tabla se eliminan también.

Modificación de un índice secundario global durante la creación


Mientras se está creando un índice, puede usar la operación DescribeTable para determinar en qué
fase se encuentra. La descripción del índice incluye un atributo booleano,BackfillingPara indicar si
DynamoDB está cargando elementos de la tabla en el índice en un momento dado. Si Backfilling es
true, significa que la fase de asignación de recursos se ha completado y el índice se encuentra en la fase
de reposició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).

Detección y corrección de infracciones de claves de índice


Durante la fase de reposición de la creación de índices secundarios globales, Amazon DynamoDB
examina cada elemento de la tabla para determinar si es apto para incluirlo en el índice. Algunos
elementos podrían no ser aptos por la posibilidad de que causen infracciones de claves de índice. En estos
casos, los elementos permanecen en la tabla, pero el índice no tiene la entrada correspondiente a dicho
elemento.

UnaInfracción de clave de índiceocurre en las siguientes situaciones:

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

Versión de API 2012-08-10


583
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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.

Descarga y ejecución del detector de infracciones


Detector de infracciones está disponible como archivo ejecutable de Java (.jar) y se ejecuta en
ordenadores Windows, macOS o Linux. Detector de infracciones requiere Java 1.7 (o posterior) y Apache
Maven.

• Descargar Detector de violaciones de GitHub

Siga las instrucciones en elREADME.mdPara descargar e instalar el Detector de infracciones mediante


Maven.

Para iniciar el Detector de infracciones, visite el directorio donde ha


construidoViolationDetector.javae introduzca el siguiente comando.

java -jar ViolationDetector.jar [options]

La línea de comandos Detector de infracciones acepta las siguientes opciones:

• -h | --help: imprime un resumen de uso y las opciones posibles de Detector de infracciones.


• -p | --configFilePath value: nombre completo de un archivo de configuración de Detector
de infracciones. Para obtener más información, consulte El archivo de configuración del detector de
infracciones (p. 584).
• -t | --detect value: detecta las infracciones de claves de índice de la tabla y las escribe en
el archivo de resultados del Detector de infracciones. Si el valor de este parámetro está establecido
enkeep, los elementos con infracciones clave no se modifican. Si el valor se establece endeleteLos
elementos con infracciones de claves se eliminan de la tabla.
• -c | --correct value: lee las infracciones de claves de índice en un archivo de información de
entrada y adopta medidas para corregir los elementos de la tabla. Si el valor de este parámetro está
establecido enupdate, los elementos con infracciones de claves se actualizan con valores nuevos sin
infracciones. Si el valor se establece endeleteLos elementos con infracciones de claves se eliminan de
la tabla.

El archivo de configuración del detector de infracciones


En tiempo de ejecución, la herramienta Detector de infracciones requiere un archivo de configuración. Los
parámetros de este archivo determinan a qué recursos de DynamoDB puede obtener acceso el Detector

Versión de API 2012-08-10


584
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

de infracciones y cuánto desempeño provisionado puede consumir. En la tabla siguiente se describen


estos parámetros.

Nombre del parámetro Descripción Obligatorio?

awsCredentialsFile El nombre completo de un Sí


archivo que contiene el valor
deAWSCredenciales de . El
archivo de credenciales debe
tener el siguiente formato:

accessKey
= access_key_id_goes_here
secretKey
= secret_key_goes_here

dynamoDBRegion LaAWSRegión en la que la Sí


reside la tabla. Por ejemplo: us-
west-2.

tableName Nombre de la tabla de Sí


DynamoDB que se va a
examinar.

gsiHashKeyName Nombre de la clave de partición Sí


del índice.

gsiHashKeyType Tipo de datos de la Sí


clave de partición del
índice:String,Number, o
bienBinary:

S | N | B

gsiRangeKeyName Nombre de la clave de No


ordenación del índice. No
especifique este parámetro si
el índice solo tiene una clave
principal simple (clave de
partición).

gsiRangeKeyType Tipo de datos de la No


clave de ordenación del
índice:String,Number, o
bienBinary:

S | N | B

No especifique este parámetro


si el índice solo tiene una clave
principal simple (clave de
partición).

recordDetails Indica si se deben escribir todos No


los detalles de las infracciones
de claves de índice en el archivo
de resultados. Si se establece
entrue(valor predeterminado),

Versión de API 2012-08-10


585
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

Nombre del parámetro Descripción Obligatorio?


se registra toda la información
sobre los elementos infractores.
Si se establece en false,
solo se registra el número de
infracciones.

Indica si se deben escribir los


recordGsiValueInViolationRecord No
valores de las claves de índice
infractoras en el archivo de
resultados. Si se establece
entrue(valor predeterminado),
se registran los valores de
las claves. Si se establece en
false, los valores de las claves
no se registran.

detectionOutputPath Ruta completa del archivo de No


resultados del Detector de
infracciones de. Este parámetro
es compatible con la escritura en
un directorio local o en Amazon
Simple Storage Service (Amazon
S3). A continuación se muestran
algunos ejemplos:

detectionOutputPath
= //local/path/
filename.csv

detectionOutputPath =
s3://bucket/filename.csv

La información del archivo


de resultados aparece en un
formato de valores separados
por comas (CSV). Si no
configuradetectionOutputPath,
el archivo de salida se
denominaviolation_detection.csvy
se escribe en el directorio de
trabajo actual.

Versión de API 2012-08-10


586
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

Nombre del parámetro Descripción Obligatorio?

numOfSegments El número de segmentos de No


examen en paralelo que se
utilizarán cuando el Detector de
infracciones examine la tabla. El
valor predeterminado es 1, lo que
significa que la tabla se examina
de forma secuencial. Si el valor
es 2 o superior, el Detector de
infracciones divide la tabla en
esa cantidad de segmentos
lógicos y un número igual de
subprocesos de examen.

El ajuste máximo de
numOfSegments es 4096.

En el caso de las tablas de


mayor tamaño, un examen
en paralelo suele resultar
más rápido que un examen
secuencial. Además, si la tabla
es lo bastante grande para
abarcar varias particiones, un
examen en paralelo distribuye su
actividad de lectura de manera
uniforme entre varias particiones.
Para obtener más información
sobre los análisis paralelos en
DynamoDB, consulteExamen en
paralelo (p. 520).

numOfViolations Límite superior de infracciones No


de claves de índice que se
escribirán en el archivo de
resultados. Si se establece
en-1(valor predeterminado), se
examinará toda la tabla. Si se
establece en un número entero
positivo, entonces el Detector
de infracciones se detendrá
después de haber detectado esa
cantidad de infracciones.

numOfRecords Número de elementos de la No


tabla que se va a examinar.
Si se establece en -1 (valor
predeterminado), se examinará
toda la tabla. Si se establece
en un número entero positivo,
el Detector de infracciones se
detendrá después de haber
examinado esa cantidad de
elementos en la tabla.

Versión de API 2012-08-10


587
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

Nombre del parámetro Descripción Obligatorio?

readWriteIOPSPercent Regula el porcentaje de unidades No


de capacidad de lectura
provisionadas que se consumen
durante un examen de la tabla.
Los valores válidos van de1De
a100. El valor predeterminado
(25) significa que el Detector
de infracciones consumirá no
más del 25% del desempeño de
lectura provisionado de la tabla.

correctionInputPath Ruta completa del archivo No


de información de entrada
de corrección del Detector
de infracciones. Si ejecuta
el Detector de infracciones
en modo de corrección, el
contenido de este archivo se
usa para modificar o eliminar los
elementos de datos de la tabla
que infringen el índice secundario
global.

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.

Versión de API 2012-08-10


588
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

Nombre del parámetro Descripción Obligatorio?

correctionOutputPath Ruta completa del archivo de No


resultados de corrección del
Detector de infracciones. Este
archivo se crea solo si existen
errores de actualización.

Este parámetro es compatible


con la escritura en un directorio
local o en Amazon S3. A
continuación se muestran
algunos ejemplos:

correctionOutputPath
= //local/path/
filename.csv

correctionOutputPath =
s3://bucket/filename.csv

La información del archivo


de resultados aparece
en formato CSV. Si no
configuracorrectionOutputPath,
el archivo de salida se
denominaviolation_update_errors.csvy
se escribe en el directorio de
trabajo actual.

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.

Id (clave principal) Precio

101 5

102 20

103 200

201 100

202 200

203 300

204 400

205 500

Versión de API 2012-08-10


589
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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

Id (clave principal) Precio

999 "Hello"

Ahora, la tabla contiene un total de nueve elementos.

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.

# Properties file for violation detection tool configuration.


# Parameters that are not specified will use default values.

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

A continuación, se ejecuta el Detector de infracciones como en el siguiente ejemplo.

$ java -jar ViolationDetector.jar --configFilePath config.txt --detect keep

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

Si el archivo derecordDetailsEl parámetro de configuración se establece entrueEl Detector de


infracciones escribe los detalles de cada infracción en el archivo de resultados, como en el siguiente
ejemplo.

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)

999,"{""S"":""Hello""}",Type Violation,Expected: N Found: S,,

Versión de API 2012-08-10


590
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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:

• Clave hash de tabla: valor de clave de partición del elemento de la tabla.


• Clave de rango de tabla: valor de clave de ordenación del elemento de la tabla.
• Valor de clave hash GSI: valor de clave de partición del índice secundario global.
• Tipo de violación de la clave hash de GSI— Ya seaType ViolationorSize Violation.
• Descripción de infracción de clave hash de GSI— La causa de la infracción.
• Valor de actualización de clave hash de GSI (PARA USUARIO): en el modo de corrección, nuevo valor
suministrado por el usuario para el atributo.
• Valor de clave de rango de GSI: valor de la clave de ordenación del índice secundario global.
• Tipo de infracción de clave de rango de GSI— Ya seaType ViolationorSize Violation.
• Descripción de infracción de clave de rango de GSI— La causa de la infracción.
• Valor de actualización de clave de rango de GSI (FOR USER): en el modo de corrección, nuevo valor
suministrado por el usuario para el atributo.
• Eliminar atributo en blanco al actualizar (S/N)— En el modo de corrección, determina si el elemento
infractor se eliminará (Y) o se conservará (N) en la tabla, pero solamente si cualquiera de los campos
siguientes está en blanco:
• GSI Hash Key Update Value(FOR USER)
• GSI Range Key Update Value(FOR USER)

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.

Versión de API 2012-08-10


591
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

$ java -jar ViolationDetector.jar --configFilePath config.txt --correct delete

En este momento, le pedirá que confirme si desea eliminar los elementos infractores.

Are you sure to delete all violations on the table?y/n


y
Confirmed, will delete violations on the table...
Violation correction from file started: Reading records from file: ./
gsi_violation_check.csv, will delete these records from table.
Violation correction from file finished: Violations delete: 1, Violations Update: 0

Ahora, tanto ProductCatalog como PriceIndex tienen el mismo número de elementos.

Uso de índices secundarios: Java


Puede utilizarAWS SDK for JavaPara crear un API de documentos que le permitirá crear una tabla de
Amazon DynamoDB con uno o varios índices secundarios globales, describir los índices de la tabla y
utilizarlos para realizar consultas.

A continuación se indican los pasos comunes para las operaciones con tablas.

1. Cree una instancia de la clase DynamoDB.


2. Cree los objetos de solicitud correspondientes para proporcionar los parámetros obligatorios y
opcionales de la operación.
3. Llame al 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. 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)

Creación de una tabla con un índice secundario global


Puede crear índices secundarios globales al mismo tiempo que crea una tabla. Para ello,
utiliceCreateTabley proporcione las especificaciones para uno o más índices secundarios globales.
En el siguiente ejemplo de código Java se crea una tabla para contener información sobre datos
meteorológicos. La clave de partición esLocationy la clave de ordenación esDate. Índice secundario
global denominadoPrecipIndexpermite obtener acceso rápido a los datos sobre precipitaciones de
varias ubicaciones.

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.

1. Cree una instancia de la clase DynamoDB.


2. Cree una instancia de la clase CreateTableRequest para proporcionar la información de solicitud.

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.

Versión de API 2012-08-10


592
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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.

Ya quePrecipitationNo es obligatorio, porque no es obligatorio. Sin embargo,WeatherDataElementos


sinPrecipitationNo aparecen enPrecipIndex.

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB dynamoDB = new DynamoDB(client);

// 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"));

// Table key schema


ArrayList<KeySchemaElement> tableKeySchema = new ArrayList<KeySchemaElement>();
tableKeySchema.add(new KeySchemaElement()
.withAttributeName("Location")
.withKeyType(KeyType.HASH)); //Partition key
tableKeySchema.add(new KeySchemaElement()
.withAttributeName("Date")
.withKeyType(KeyType.RANGE)); //Sort key

// PrecipIndex
GlobalSecondaryIndex precipIndex = new GlobalSecondaryIndex()
.withIndexName("PrecipIndex")
.withProvisionedThroughput(new ProvisionedThroughput()
.withReadCapacityUnits((long) 10)
.withWriteCapacityUnits((long) 1))
.withProjection(new Projection().withProjectionType(ProjectionType.ALL));

ArrayList<KeySchemaElement> indexKeySchema = new ArrayList<KeySchemaElement>();

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

CreateTableRequest createTableRequest = new CreateTableRequest()


.withTableName("WeatherData")
.withProvisionedThroughput(new ProvisionedThroughput()
.withReadCapacityUnits((long) 5)
.withWriteCapacityUnits((long) 1))
.withAttributeDefinitions(attributeDefinitions)
.withKeySchema(tableKeySchema)
.withGlobalSecondaryIndexes(precipIndex);

Table table = dynamoDB.createTable(createTableRequest);


System.out.println(table.getDescription());

Versión de API 2012-08-10


593
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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.

Describir una tabla con un índice secundario global


Para obtener información acerca de los índices secundarios globales de una tabla, useDescribeTable.
Para cada índice, puede obtener acceso a su nombre, esquema de claves y atributos proyectados.

Los siguientes son los pasos para acceder a la información de índice secundario global de una tabla.

1. Cree una instancia de la clase DynamoDB.


2. Cree una instancia de la clase Table para representar el índice que desea usar.
3. Llame al método describe del objeto Table.

En el siguiente ejemplo de código Java se muestran los pasos anteriores.

Example

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("WeatherData");


TableDescription tableDesc = table.describe();

Iterator<GlobalSecondaryIndexDescription> gsiIter =
tableDesc.getGlobalSecondaryIndexes().iterator();
while (gsiIter.hasNext()) {
GlobalSecondaryIndexDescription gsiDesc = gsiIter.next();
System.out.println("Info for index "
+ gsiDesc.getIndexName() + ":");

Iterator<KeySchemaElement> kseIter = gsiDesc.getKeySchema().iterator();


while (kseIter.hasNext()) {
KeySchemaElement kse = kseIter.next();
System.out.printf("\t%s: %s\n", kse.getAttributeName(), kse.getKeyType());
}
Projection projection = gsiDesc.getProjection();
System.out.println("\tThe projection type is: "
+ projection.getProjectionType());
if (projection.getProjectionType().toString().equals("INCLUDE")) {
System.out.println("\t\tThe non-key projected attributes are: "
+ projection.getNonKeyAttributes());
}
}

Consulta de un índice secundario global


Puede usarQueryEn un índice secundario global, de un modo bastante similar aQueryUna tabla de. Debe
especificar el nombre del índice, los criterios de consulta de la clave de partición y la clave de ordenación
(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 muestran los pasos para consultar un índice secundario global mediante elAWS SDK
for JavaDocumentación de la API

1. Cree una instancia de la clase DynamoDB.

Versión de API 2012-08-10


594
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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.

En el siguiente ejemplo de código Java se muestran los pasos anteriores.

Example

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB dynamoDB = new DynamoDB(client);

Table table = dynamoDB.getTable("WeatherData");


Index index = table.getIndex("PrecipIndex");

QuerySpec spec = new QuerySpec()


.withKeyConditionExpression("#d = :v_date and Precipitation = :v_precip")
.withNameMap(new NameMap()
.with("#d", "Date"))
.withValueMap(new ValueMap()
.withString(":v_date","2013-08-10")
.withNumber(":v_precip",0));

ItemCollection<QueryOutcome> items = index.query(spec);


Iterator<Item> iter = items.iterator();
while (iter.hasNext()) {
System.out.println(iter.next().toJSONPretty());
}

Ejemplo: Índices secundarios globales utilizando el parámetroAWS SDK for


JavaDocumentación de la API
En el siguiente ejemplo de código Java se muestra cómo usar índices secundarios globales. En el ejemplo,
se crea una tabla llamadaIssues, que puede utilizarse en un sistema sencillo de seguimiento de errores
con fines de desarrollo de software. La clave de partición esIssueIdy la clave de ordenación esTitle.
Hay tres índices secundarios globales en esta tabla:

• CreateDateIndex: la clave de partición esCreateDatey la clave de ordenación esIssueId. Además


de las claves de tabla, los atributosDescriptionyStatusSe proyectan en el índice.
• TitleIndex: la clave de partición esTitley la clave de ordenación esIssueId. No se proyecta en el
índice ningún otro atributo excepto las claves de tabla.
• DueDateIndex: la clave de partición esDueDate, y no hay clave de ordenación. Todos los atributos de
la tabla se proyectan en el índice.

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.

Versión de API 2012-08-10


595
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

*
* 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;

public class DocumentAPIGlobalSecondaryIndexExample {

static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


static DynamoDB dynamoDB = new DynamoDB(client);

public static String tableName = "Issues";

public static void main(String[] args) throws Exception {

createTable();
loadData();

queryIndex("CreateDateIndex");
queryIndex("TitleIndex");
queryIndex("DueDateIndex");

deleteTable(tableName);

public static void createTable() {

// Attribute definitions
ArrayList<AttributeDefinition> attributeDefinitions = new
ArrayList<AttributeDefinition>();

attributeDefinitions.add(new
AttributeDefinition().withAttributeName("IssueId").withAttributeType("S"));
attributeDefinitions.add(new
AttributeDefinition().withAttributeName("Title").withAttributeType("S"));

Versión de API 2012-08-10


596
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

attributeDefinitions.add(new
AttributeDefinition().withAttributeName("CreateDate").withAttributeType("S"));
attributeDefinitions.add(new
AttributeDefinition().withAttributeName("DueDate").withAttributeType("S"));

// Key schema for table


ArrayList<KeySchemaElement> tableKeySchema = new ArrayList<KeySchemaElement>();
tableKeySchema.add(new
KeySchemaElement().withAttributeName("IssueId").withKeyType(KeyType.HASH)); // Partition

// key
tableKeySchema.add(new
KeySchemaElement().withAttributeName("Title").withKeyType(KeyType.RANGE)); // Sort

// key

// Initial provisioned throughput settings for the indexes


ProvisionedThroughput ptIndex = new
ProvisionedThroughput().withReadCapacityUnits(1L)
.withWriteCapacityUnits(1L);

// 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"));

CreateTableRequest createTableRequest = new


CreateTableRequest().withTableName(tableName)
.withProvisionedThroughput(
new ProvisionedThroughput().withReadCapacityUnits((long)
1).withWriteCapacityUnits((long) 1))

Versión de API 2012-08-10


597
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

.withAttributeDefinitions(attributeDefinitions).withKeySchema(tableKeySchema)
.withGlobalSecondaryIndexes(createDateIndex, titleIndex, dueDateIndex);

System.out.println("Creating table " + tableName + "...");


dynamoDB.createTable(createTableRequest);

// Wait for table to become active


System.out.println("Waiting for " + tableName + " to become ACTIVE...");
try {
Table table = dynamoDB.getTable(tableName);
table.waitForActive();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}

public static void queryIndex(String indexName) {

Table table = dynamoDB.getTable(tableName);

System.out.println("\n***********************************************************
\n");
System.out.print("Querying index " + indexName + "...");

Index index = table.getIndex(indexName);

ItemCollection<QueryOutcome> items = null;

QuerySpec querySpec = new QuerySpec();

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;
}

Iterator<Item> iterator = items.iterator();

System.out.println("Query: printing results...");

while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}

Versión de API 2012-08-10


598
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

public static void deleteTable(String tableName) {

System.out.println("Deleting table " + tableName + "...");

Table table = dynamoDB.getTable(tableName);


table.delete();

// Wait for table to be deleted


System.out.println("Waiting for " + tableName + " to be deleted...");
try {
table.waitForDelete();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}

public static void loadData() {

System.out.println("Loading data into table " + tableName + "...");

// IssueId, Title,
// Description,
// CreateDate, LastUpdateDate, DueDate,
// Priority, Status

putItem("A-101", "Compilation error", "Can't compile Project X - bad version


number. What does this mean?",
"2013-11-01", "2013-11-02", "2013-11-10", 1, "Assigned");

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

putItem("A-103", "Test failure", "Functional test of Project X produces errors",


"2013-11-01", "2013-11-02",
"2013-11-10", 1, "In progress");

putItem("A-104", "Compilation error", "Variable 'messageCount' was not


initialized.", "2013-11-15",
"2013-11-16", "2013-11-30", 3, "Assigned");

putItem("A-105", "Network issue", "Can't ping IP address 127.0.0.1. Please fix


this.", "2013-11-15",
"2013-11-16", "2013-11-19", 5, "Assigned");

public static void putItem(

String issueId, String title, String description, String createDate, String


lastUpdateDate, String dueDate,
Integer priority, String status) {

Table table = dynamoDB.getTable(tableName);

Item item = new Item().withPrimaryKey("IssueId", issueId).withString("Title",


title)
.withString("Description", description).withString("CreateDate", createDate)
.withString("LastUpdateDate", lastUpdateDate).withString("DueDate", dueDate)
.withNumber("Priority", priority).withString("Status", status);

table.putItem(item);
}

Versión de API 2012-08-10


599
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

Uso de índices secundarios: .NET


Puede utilizarAWS SDK for .NETPara crear una tabla de Amazon DynamoDB con uno o varios
índices secundarios globales, describir los índices de la tabla y utilizarlos para realizar consultas.
Estas operaciones se mapean a las operaciones correspondientes de DynamoDB. Para obtener más
información, consulte laReferencia de la API de Amazon DynamoDB.

A continuación se indican los pasos comunes para las operaciones con tablas mediante el API de bajo
nivel de .NET.

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree los objetos de solicitud correspondientes para proporcionar los parámetros obligatorios y
opcionales de la operación.

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)

Creación de una tabla con un índice secundario global


Puede crear índices secundarios globales al mismo tiempo que crea una tabla. Para ello,
utiliceCreateTabley proporcione las especificaciones para uno o más índices secundarios globales.
En el siguiente ejemplo de código C# se crea una tabla para contener información sobre datos
meteorológicos. La clave de partición esLocationy la clave de ordenación esDate. Índice secundario
global denominadoPrecipIndexpermite obtener acceso rápido a los datos sobre precipitaciones de
varias ubicaciones.

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.

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree una instancia de la clase CreateTableRequest para proporcionar la información de solicitud.

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

Versión de API 2012-08-10


600
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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.

Ya quePrecipitationNo es obligatorio, porque no es obligatorio. Sin embargo,WeatherDataElementos


sinPrecipitationNo aparecen enPrecipIndex.

client = new AmazonDynamoDBClient();


string tableName = "WeatherData";

// 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"}
}
};

// Table key schema


var tableKeySchema = new List<KeySchemaElement>()
{
{new KeySchemaElement {
AttributeName = "Location",
KeyType = "HASH"}}, //Partition key
{new KeySchemaElement {
AttributeName = "Date",
KeyType = "RANGE"} //Sort key
}
};

// PrecipIndex
var precipIndex = new GlobalSecondaryIndex
{
IndexName = "PrecipIndex",
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = (long)10,
WriteCapacityUnits = (long)1
},
Projection = new Projection { ProjectionType = "ALL" }
};

var indexKeySchema = new List<KeySchemaElement> {


{new KeySchemaElement { AttributeName = "Date", KeyType = "HASH"}}, //Partition key
{new KeySchemaElement{AttributeName = "Precipitation",KeyType = "RANGE"}} //Sort key
};

precipIndex.KeySchema = indexKeySchema;

CreateTableRequest createTableRequest = new CreateTableRequest


{
TableName = tableName,
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = (long)5,
WriteCapacityUnits = (long)1
},
AttributeDefinitions = attributeDefinitions,
KeySchema = tableKeySchema,

Versión de API 2012-08-10


601
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

GlobalSecondaryIndexes = { precipIndex }
};

CreateTableResponse response = client.CreateTable(createTableRequest);


Console.WriteLine(response.CreateTableResult.TableDescription.TableName);
Console.WriteLine(response.CreateTableResult.TableDescription.TableStatus);

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.

Describir una tabla con un índice secundario global


Para obtener información acerca de los índices secundarios globales de una tabla, useDescribeTable.
Para cada índice, puede obtener acceso a su nombre, esquema de claves y atributos proyectados.

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.

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Ejecute ladescribeTableMétodo proporcionando el objeto de solicitud como parámetro.

Cree una instancia de la clase DescribeTableRequest para proporcionar la información de


solicitud. Debe proporcionar el nombre de la tabla.
3.

En el siguiente ejemplo de código C# se ponen en práctica los pasos anteriores.

Example

client = new AmazonDynamoDBClient();


string tableName = "WeatherData";

DescribeTableResponse response = client.DescribeTable(new DescribeTableRequest { TableName


= tableName});

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.

foreach (GlobalSecondaryIndexDescription gsiDescription in globalSecondaryIndexes) {


Console.WriteLine("Info for index " + gsiDescription.IndexName + ":");

foreach (KeySchemaElement kse in gsiDescription.KeySchema) {


Console.WriteLine("\t" + kse.AttributeName + ": key type is " + kse.KeyType);
}

Projection projection = gsiDescription.Projection;


Console.WriteLine("\tThe projection type is: " + projection.ProjectionType);

if (projection.ProjectionType.ToString().Equals("INCLUDE")) {
Console.WriteLine("\t\tThe non-key projected attributes are: "
+ projection.NonKeyAttributes);
}
}

Consulta de un índice secundario global


Puede usarQueryEn un índice secundario global, de un modo bastante similar aQueryUna tabla de. Debe
especificar el nombre del índice, los criterios de consulta de la clave de partición y la clave de ordenación

Versión de API 2012-08-10


602
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

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

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree una instancia de la clase QueryRequest para proporcionar la información de solicitud.
3. Ejecute laqueryMétodo proporcionando el objeto de solicitud como parámetro.

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.

En el siguiente ejemplo de código C# se ponen en práctica los pasos anteriores.

Example

client = new AmazonDynamoDBClient();

QueryRequest queryRequest = new QueryRequest


{
TableName = "WeatherData",
IndexName = "PrecipIndex",
KeyConditionExpression = "#dt = :v_date and Precipitation > :v_precip",
ExpressionAttributeNames = new Dictionary<String, String> {
{"#dt", "Date"}
},
ExpressionAttributeValues = new Dictionary<string, AttributeValue> {
{":v_date", new AttributeValue { S = "2013-08-01" }},
{":v_precip", new AttributeValue { N = "0" }}
},
ScanIndexForward = true
};

var result = client.Query(queryRequest);

var items = result.Items;


foreach (var currentItem in items)
{
foreach (string attr in currentItem.Keys)
{
Console.Write(attr + "---> ");
if (attr == "Precipitation")
{
Console.WriteLine(currentItem[attr].N);
}
else
{
Console.WriteLine(currentItem[attr].S);
}

}
Console.WriteLine();
}

Versión de API 2012-08-10


603
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

Ejemplo: Índices secundarios globales utilizando el parámetroAWS SDK


for .NETAPI de bajo nivel
En el siguiente ejemplo de código C# se muestra cómo usar índices secundarios globales. En el ejemplo,
se crea una tabla llamadaIssues, que puede utilizarse en un sistema sencillo de seguimiento de errores
con fines de desarrollo de software. La clave de partición esIssueIdy la clave de ordenación esTitle.
Hay tres índices secundarios globales en esta tabla:

• CreateDateIndex: la clave de partición esCreateDatey la clave de ordenación esIssueId. Además


de las claves de tabla, los atributosDescriptionyStatusSe proyectan en el índice.
• TitleIndex: la clave de partición esTitley la clave de ordenación esIssueId. No se proyecta en el
índice ningún otro atributo excepto las claves de tabla.
• DueDateIndex: la clave de partición esDueDate, y no hay clave de ordenación. Todos los atributos de
la tabla se proyectan en el índice.

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";

public static void Main(string[] args)


{
CreateTable();
LoadData();

Versión de API 2012-08-10


604
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

QueryIndex("CreateDateIndex");
QueryIndex("TitleIndex");
QueryIndex("DueDateIndex");

DeleteTable(tableName);

Console.WriteLine("To continue, press enter");


Console.Read();
}

private static void CreateTable()


{
// Attribute definitions
var attributeDefinitions = new List<AttributeDefinition>()
{
{new AttributeDefinition {
AttributeName = "IssueId", AttributeType = "S"
}},
{new AttributeDefinition {
AttributeName = "Title", AttributeType = "S"
}},
{new AttributeDefinition {
AttributeName = "CreateDate", AttributeType = "S"
}},
{new AttributeDefinition {
AttributeName = "DueDate", AttributeType = "S"
}}
};

// Key schema for table


var tableKeySchema = new List<KeySchemaElement>() {
{
new KeySchemaElement {
AttributeName= "IssueId",
KeyType = "HASH" //Partition key
}
},
{
new KeySchemaElement {
AttributeName = "Title",
KeyType = "RANGE" //Sort key
}
}
};

// Initial provisioned throughput settings for the indexes


var ptIndex = new ProvisionedThroughput
{
ReadCapacityUnits = 1L,
WriteCapacityUnits = 1L
};

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

Versión de API 2012-08-10


605
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

{
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"
}
};

var createTableRequest = new CreateTableRequest


{
TableName = tableName,
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = (long)1,
WriteCapacityUnits = (long)1
},
AttributeDefinitions = attributeDefinitions,
KeySchema = tableKeySchema,
GlobalSecondaryIndexes = {
createDateIndex, titleIndex, dueDateIndex
}
};

Console.WriteLine("Creating table " + tableName + "...");


client.CreateTable(createTableRequest);

WaitUntilTableReady(tableName);
}

Versión de API 2012-08-10


606
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

private static void LoadData()


{
Console.WriteLine("Loading data into table " + tableName + "...");

// IssueId, Title,
// Description,
// CreateDate, LastUpdateDate, DueDate,
// Priority, Status

putItem("A-101", "Compilation error",


"Can't compile Project X - bad version number. What does this mean?",
"2013-11-01", "2013-11-02", "2013-11-10",
1, "Assigned");

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

putItem("A-103", "Test failure",


"Functional test of Project X produces errors",
"2013-11-01", "2013-11-02", "2013-11-10",
1, "In progress");

putItem("A-104", "Compilation error",


"Variable 'messageCount' was not initialized.",
"2013-11-15", "2013-11-16", "2013-11-30",
3, "Assigned");

putItem("A-105", "Network issue",


"Can't ping IP address 127.0.0.1. Please fix this.",
"2013-11-15", "2013-11-16", "2013-11-19",
5, "Assigned");
}

private static void putItem(


String issueId, String title,
String description,
String createDate, String lastUpdateDate, String dueDate,
Int32 priority, String status)
{
Dictionary<String, AttributeValue> item = new Dictionary<string,
AttributeValue>();

item.Add("IssueId", new AttributeValue


{
S = issueId
});
item.Add("Title", new AttributeValue
{
S = title
});
item.Add("Description", new AttributeValue
{
S = description
});
item.Add("CreateDate", new AttributeValue
{
S = createDate
});
item.Add("LastUpdateDate", new AttributeValue
{
S = lastUpdateDate
});
item.Add("DueDate", new AttributeValue

Versión de API 2012-08-10


607
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

{
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());
}
}

private static void QueryIndex(string indexName)


{
Console.WriteLine
("\n***********************************************************\n");
Console.WriteLine("Querying index " + indexName + "...");

QueryRequest queryRequest = new QueryRequest


{
TableName = tableName,
IndexName = indexName,
ScanIndexForward = true
};

String keyConditionExpression;
Dictionary<string, AttributeValue> expressionAttributeValues = new
Dictionary<string, AttributeValue>();

if (indexName == "CreateDateIndex")
{
Console.WriteLine("Issues filed on 2013-11-01\n");

keyConditionExpression = "CreateDate = :v_date and


begins_with(IssueId, :v_issue)";
expressionAttributeValues.Add(":v_date", new AttributeValue
{
S = "2013-11-01"
});
expressionAttributeValues.Add(":v_issue", new AttributeValue
{
S = "A-"
});
}
else if (indexName == "TitleIndex")
{
Console.WriteLine("Compilation errors\n");

keyConditionExpression = "Title = :v_title and


begins_with(IssueId, :v_issue)";
expressionAttributeValues.Add(":v_title", new AttributeValue

Versión de API 2012-08-10


608
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

{
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");

keyConditionExpression = "DueDate = :v_date";


expressionAttributeValues.Add(":v_date", new AttributeValue
{
S = "2013-11-30"
});

// Select
queryRequest.Select = "ALL_PROJECTED_ATTRIBUTES";
}
else
{
Console.WriteLine("\nNo valid index name provided");
return;
}

queryRequest.KeyConditionExpression = keyConditionExpression;
queryRequest.ExpressionAttributeValues = expressionAttributeValues;

var result = client.Query(queryRequest);


var items = result.Items;
foreach (var currentItem in items)
{
foreach (string attr in currentItem.Keys)
{
if (attr == "Priority")
{
Console.WriteLine(attr + "---> " + currentItem[attr].N);
}
else
{
Console.WriteLine(attr + "---> " + currentItem[attr].S);
}
}
Console.WriteLine();
}
}

private static void DeleteTable(string tableName)


{
Console.WriteLine("Deleting table " + tableName + "...");
client.DeleteTable(new DeleteTableRequest
{
TableName = tableName
});
WaitForTableToBeDeleted(tableName);
}

private static void WaitUntilTableReady(string tableName)


{
string status = null;
// Let us wait until table is created. Call DescribeTable.

Versión de API 2012-08-10


609
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

do
{
System.Threading.Thread.Sleep(5000); // Wait 5 seconds.
try
{
var res = client.DescribeTable(new DescribeTableRequest
{
TableName = tableName
});

Console.WriteLine("Table name: {0}, status: {1}",


res.Table.TableName,
res.Table.TableStatus);
status = res.Table.TableStatus;
}
catch (ResourceNotFoundException)
{
// DescribeTable is eventually consistent. So you might
// get resource not found. So we handle the potential exception.
}
} while (status != "ACTIVE");
}

private static void WaitForTableToBeDeleted(string tableName)


{
bool tablePresent = true;

while (tablePresent)
{
System.Threading.Thread.Sleep(5000); // Wait 5 seconds.
try
{
var res = client.DescribeTable(new DescribeTableRequest
{
TableName = tableName
});

Console.WriteLine("Table name: {0}, status: {1}",


res.Table.TableName,
res.Table.TableStatus);
}
catch (ResourceNotFoundException)
{
tablePresent = false;
}
}
}
}
}

Trabajo con índices secundarios:AWS CLI


Puede utilizarAWS CLIPara crear una tabla de Amazon DynamoDB con uno o varios índices secundarios
globales, describir los índices de la tabla y utilizarlos para realizar consultas.

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)

Versión de API 2012-08-10


610
Amazon DynamoDB Guía para desarrolladores
Índices secundarios globales

Crear una tabla con un índice secundario global


Se pueden crear índices secundarios globales al mismo tiempo que se crea una tabla. Para ello, utilice
lacreate-tabley proporcione sus especificaciones para uno o más índices secundarios globales.
En el siguiente ejemplo se crea una tabla llamadaGameScoresCon un índice secundario global
llamadoGameTitleIndex. La tabla base tiene una clave de particiónUserIdy una clave de clasificación
deGameTitle, lo que le permite encontrar eficientemente la mejor puntuación de un usuario individual
para un juego específico, mientras que el GSI tiene una clave de partición deGameTitley una clave de
clasificación deTopScore, lo que te permite encontrar rápidamente la puntuación más alta en general para
un juego en particular.

aws dynamodb create-table \


--table-name GameScores \
--attribute-definitions AttributeName=UserId,AttributeType=S \
AttributeName=GameTitle,AttributeType=S \
AttributeName=TopScore,AttributeType=N \
--key-schema AttributeName=UserId,KeyType=HASH \
AttributeName=GameTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
--global-secondary-indexes \
"[
{
\"IndexName\": \"GameTitleIndex\",
\"KeySchema\": [{\"AttributeName\":\"GameTitle\",\"KeyType\":\"HASH\"},
{\"AttributeName\":\"TopScore\",\"KeyType\":\"RANGE\"}],
\"Projection\":{
\"ProjectionType\":\"INCLUDE\",
\"NonKeyAttributes\":[\"UserId\"]
}
}
]"

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.

Agregar un índice secundario global a una tabla existente


Los índices secundarios globales también se pueden agregar o modificar después de la creación de
la tabla. Para ello, utilice laupdate-tabley proporcione sus especificaciones para uno o más índices
secundarios globales. En el siguiente ejemplo se utiliza el mismo esquema que el ejemplo anterior, pero se
supone que la tabla ya se ha creado y que vamos a agregar el GSI más adelante.

aws dynamodb update-table \


--table-name GameScores \
--attribute-definitions AttributeName=TopScore,AttributeType=N \
--global-secondary-index-updates \
"[
{
\"Create\": {
\"IndexName\": \"GameTitleIndex\",
\"KeySchema\": [{\"AttributeName\":\"GameTitle\",\"KeyType\":\"HASH\"},
{\"AttributeName\":\"TopScore\",\"KeyType\":\"RANGE
\"}],
\"Projection\":{
\"ProjectionType\":\"INCLUDE\",
\"NonKeyAttributes\":[\"UserId\"]
}
}
}
]"

Versión de API 2012-08-10


611
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

Describir una tabla de con un índice secundario global


Para obtener información acerca de los índices secundarios locales en una tabla, utilice la
herramientadescribe-tableParámetro. Para cada índice, puede obtener acceso a su nombre, esquema
de claves y atributos proyectados.

aws dynamodb describe-table --table-name GameScores

Consulta de un índice secundario global


Puede utilizarqueryoperación en un índice secundario global de la misma manera quequeryUna tabla de.
Debe especificar el nombre del índice, los criterios de consulta de la clave de ordenación del índice y los
atributos que desea devolver. En este ejemplo, el índice esGameTitleIndexy la clave de ordenación del
índice esGameTitle.

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

aws dynamodb query \


--index-name GameTitleIndex \
--key-condition-expression "GameTitle = :v_game" \
--expression-attribute-values '{":v_game":{"S":"Alien Adventure"} }'

Índices secundarios locales


Algunas aplicaciones solo requieren consultar datos utilizando la clave principal de la tabla base. Sin
embargo, puede haber situaciones en las que una clave de ordenación alternativa sería útil. Para que
la aplicación disponga de diversas claves de ordenación entre las que elegir, puede crear uno o varios
índices secundarios locales en una tabla de Amazon DynamoDB y emitir unQueryorScansolicitudes contra
estos índices.

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)

ESCENARIO Uso de un índice secundario local


Como ejemplo, considere laThreadque se define enCreación de tablas y carga de datos para ejemplos
de código en DynamoDB (p. 333). Esta tabla resulta útil para una aplicación como, por ejemplo,AWSForos
de debate de. En el siguiente diagrama se muestra cómo se organizarían los elementos de la tabla. No se
muestran todos los atributos.

Versión de API 2012-08-10


612
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

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.

Versión de API 2012-08-10


613
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

En el siguiente diagrama se muestra un índice secundario local denominadoLastPostIndex.


Tenga en cuenta que la clave de partición es la misma que la deThread, pero la clave de ordenación
esLastPostDateTime.

Cada índice secundario local debe cumplir las condiciones siguientes:

• La clave de partición ha de ser la misma que aquella de la tabla base.


• La clave de ordenación consta exactamente de un atributo escalar.
• La clave de ordenación de la tabla base se proyectará en el índice, donde actuará como atributo sin
clave.

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.

Versión de API 2012-08-10


614
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

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.

Versión de API 2012-08-10


615
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

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.

En el diagrama anterior, el atributo sin claveRepliesse proyecta enLastPostIndex. Una


aplicación puede consultarLastPostIndexEn lugar de laThreadpara rellenar una página web
conSubject,Replies, yLastPostDateTime. Si se solicitasen otros atributos sin clave, DynamoDB
tendría que recuperarlos en elThreadTabla INTO

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.

Creación de un índice secundario local


Para crear uno o varios índices secundarios locales en una tabla, se usa
elLocalSecondaryIndexesParámetro deCreateTable. Los índices secundarios locales de una tabla
se crean cuando se crea la tabla. Al eliminar una tabla, también se eliminan todos los índices secundarios
locales de esa tabla.

Versión de API 2012-08-10


616
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

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

Lectura de datos de un índice secundario local


Puede recuperar elementos de un índice secundario local utilizando la
herramientaQueryyScanOperaciones. LaGetItemyBatchGetItemLas operaciones no se pueden utilizar
en un índice secundario local.

Consulta de un índice secundario local


En una tabla de DynamoDB, la combinación de valor de clave de partición y valor de clave de ordenación
de cada elemento debe ser única. Sin embargo, en un índice secundario local, no es preciso que el valor
de la clave de ordenación sea exclusivo para un determinado valor de clave de partición. Si en el índice
secundario local hay varios elementos que tienen el mismo valor de clave de ordenación, se muestra
unQuerydevuelve todos los elementos que tienen el mismo valor de clave de partición. En la respuesta,
los elementos coincidentes no se devuelven en ningún orden concreto.

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:

Versión de API 2012-08-10


617
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

• Accesos de DynamoDBLastPostIndex, mediante laForumNamePara localizar los elementos del


índice correspondientes a «EC2". Todos los elementos de índice que tienen esta clave se almacenan en
posiciones adyacentes, para agilizar su recuperación.
• En este foro, DynamoDB utiliza el índice para buscar las claves que coinciden con el
especificadoLastPostDateTimeCondición.
• Ya queRepliesse proyecta en el índice, DynamoDB puede recuperar este atributo sin consumir ningún
desempeño provisionado adicional.
• LaTagsno se proyecta en el índice, de tal forma que DynamoDB debe obtener acceso al
atributoThready obtener este atributo.
• Se devuelven los resultados ordenados según el valor deLastPostDateTime. Las entradas de índice
se ordenan según el valor de la clave de partición y, a continuación, según el valor de la clave de
ordenación;Querylos devuelve en el orden en que están almacenados. Puede utilizar el parámetro
ScanIndexForward para devolver los resultados en orden descendente.

Ya queTagsPara recuperar este atributo de la tabla base no se ha proyectado en el índice secundario


local, DynamoDB debe consumir unidades de capacidad de lectura adicionales. Si necesita ejecutar esta
consulta a menudo, debe proyectarTagsenLastPostIndexPara evitar la obtención de la tabla base. Sin
embargo, si necesitabas acceder aTagssólo ocasionalmente, el costo de almacenamiento adicional para
proyectarTagsen el índice puede no valer la pena.

Análisis de un índice secundario local


Puede usarScanPara recuperar todos los datos de un índice secundario local. Debe proporcionar el
nombre de la tabla base y el nombre del índice en la solicitud. Con unScan, DynamoDB lee todos los datos
del índice y los devuelve a la aplicación. También puede solicitar que solo se devuelvan algunos de los
datos y se descarten los demás. Para ello, utilice laFilterExpressionParámetro deScanAPI. Para
obtener más información, consulte Expresiones de filtro para Scan (p. 516).

Escritura de elementos e índices secundarios


DynamoDB mantiene sincronizados automáticamente todos los índices secundarios locales con sus tablas
base respectivas. Las aplicaciones nunca escriben directamente en un índice. Sin embargo, es importante
comprender las implicaciones de cómo DynamoDB mantiene estos índices.

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

Versión de API 2012-08-10


618
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

Consideraciones sobre el desempeño provisionado para los


índices secundarios locales
Al crear una tabla en DynamoDB, se provisionan unidades de capacidad de lectura y escritura para la
carga de trabajo prevista de esa tabla. Esta carga de trabajo incluye la actividad de lectura y escritura en
los índices secundarios locales de la tabla.

Para ver las tarifas vigentes de capacidad de desempeño provisionada, consultePrecios de Amazon
DynamoDB.

Unidades de capacidad de lectura


Al consultar un índice secundario local, el número de unidades de capacidad de lectura consumidas
depende de cómo se obtiene acceso a los datos.

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:

• El tamaño de los elementos coincidentes del índice, redondeado al múltiplo de 4 KB siguientes.


• El tamaño de cada elemento coincidente de la tabla base, redondeado individualmente al múltiplo de 4
KB siguientes.

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:

Versión de API 2012-08-10


619
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

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

Por lo tanto, el tamaño total de los datos del resultado es de 20 KB.

Unidades de capacidad de escritura


Cuando se agrega, actualiza o elimina un elemento de una tabla, la actualización de los índices
secundarios locales consume unidades de capacidad de escritura provisionadas para la tabla. El costo
total de desempeño provisionado de una escritura es la suma de las unidades de capacidad de escritura
consumidas al escribir en la tabla y aquellas consumidas al actualizar los índices secundarios locales.

El costo de escribir un elemento en un índice secundario local depende de varios factores:

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

Consideraciones sobre el almacenamiento para los índices


secundarios locales
Cuando una aplicación escribe un elemento en una tabla, DynamoDB copia automáticamente el
subconjunto de atributos en todos los índices secundarios locales en los que deban aparecer esos
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 locales de esa tabla.

La cantidad de espacio utilizado por un elemento de índice es la suma de lo siguiente:

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

Versión de API 2012-08-10


620
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

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.

En DynamoDB, unColección de elementosEs cualquier grupo de elementos que tienen el mismo


valor de clave de partición en una tabla y en todos los índices secundarios locales. En los ejemplos
utilizados en esta sección, la clave de partición para elThreadLa tabla esForumNamey la clave de
particiónLastPostIndexTambién esForumName. Todos los elementos de tabla e índice que tienen el
mismoForumNameforman parte de la misma colección de elementos. Por ejemplo, en elThreadTabla
yLastPostIndexíndice secundario local, hay una colección de elementos para el foroEC2y una colección
de artículos diferente para el foroRDS.

En el siguiente diagrama se muestra la colección de elementos del foroS3.

Versión de API 2012-08-10


621
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

En este diagrama, la colección de elementos consta de todos los elementos


deThreadyLastPostIndexdondeForumNamevalor de clave de partición es «S3". Si había otros índices
secundarios locales en la tabla, los elementos de esos índices conForumNameIgual a «S3" también
formará parte de la colección de elementos.

Puede utilizar cualquiera de las siguientes operaciones de DynamoDB para devolver información sobre las
colecciones de elementos:

Versión de API 2012-08-10


622
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

• BatchWriteItem
• DeleteItem
• PutItem
• UpdateItem

Todas estas operaciones admiten elReturnItemCollectionMetricsParámetro. Si establece este


parámetro en SIZE, podrá ver información sobre el tamaño de cada colección de elementos en el índice.

Example

A continuación se muestra un ejemplo de la salida de unUpdateItemOperacion en laThreadcon


tabla deReturnItemCollectionMetricsse establece enSIZE. El elemento que se actualizó tenía
unForumNameDe «EC2", por lo que el resultado incluye información acerca de esa colección de
elementos.

{
ItemCollectionMetrics: {
ItemCollectionKey: {
ForumName: "EC2"
},
SizeEstimateRangeGB: [0.0, 1.0]
}
}

LaSizeEstimateRangeGBmuestra que el tamaño de esta colección de elementos está comprendido


entre 0 y 1 GB. DynamoDB actualiza periódicamente este cálculo del tamaño, de modo que las cifras
podrían ser distintas la próxima vez que se modifique el elemento.

Límite de tamaño de una colección de elementos


El tamaño máximo de una colección de elementos es de 10 GB. Este límite no se aplica a las tablas sin
índices secundarios locales. Sólo las tablas que tienen uno o más índices secundarios locales se ven
afectadas.

Si una colección de elementos supera el límite de 10 GB, DynamoDB devuelve


unItemCollectionSizeLimitExceededExceptionNo podrá agregar más elementos a la colección
de elementos ni incrementar los tamaños de los elementos contenidos en ella. Las operaciones de lectura
y escritura que reduzcan el tamaño de la colección de elementos sí se permitirán. También se pueden
agregar elementos a otras colecciones de elementos.

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.

Versión de API 2012-08-10


623
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

Como práctica recomendada, es preferible instrumentar la aplicación de tal forma que


monitorice los tamaños de las colecciones de elementos. Una forma de hacerlo es
establecer el valor deReturnItemCollectionMetricsParámetro deSIZEcada vez que
useBatchWriteItem,DeleteItem,PutItem, o bienUpdateItem. Su solicitud debe examinar
elReturnItemCollectionMetricsUn objeto en el resultado y registra un mensaje de error cada vez
que una colección de elementos supere un límite definido por el usuario (8 GB, por ejemplo). Establecer
un límite inferior a 10 GB proporcionará un mecanismo de advertencia precoz sistema que le permitirá
saber qué colección de elementos está próxima a alcanzar el límite a tiempo para adoptar las medidas
pertinentes.

Colecciones de elementos y particiones


Los datos de tabla e índice de cada colección de elementos se guardan en una misma partición.
Refiriéndose alThreadEjemplo de la tabla, todos los elementos de la tabla base y del índice cuyos valores
delForumNamese almacenaría en la misma partición. La colección de elementos "S3" se almacenaría en
una partición, "EC2", en otra, y "RDS", en una tercera.

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.

Uso de índices secundarios: Java


Puede utilizarAWS SDK for JavaPara crear un API de documentos que le permitirá crear una tabla de
Amazon DynamoDB con uno o varios índices secundarios locales, describir los índices de la tabla y
utilizarlos para realizar consultas.

A continuación se indican los pasos comunes para las operaciones con tablas mediante el API de
documentos del AWS SDK for Java.

1. Cree una instancia de la clase DynamoDB.


2. Cree los objetos de solicitud correspondientes para proporcionar los parámetros obligatorios y
opcionales de la operación.
3. Llame al método apropiado proporcionado por el cliente que ha creado en el paso anterior.

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)

Creación de una tabla con un índice secundario local


Los índices secundarios locales se deben crear a la vez que se crea la tabla. Para ello, utilice
lacreateTabley proporcione las especificaciones para uno o más índices secundarios locales. En el
siguiente ejemplo de código Java se crea una tabla para contener información sobre las canciones de una
colección de música. La clave de partición esArtisty la clave de ordenación esSongTitle. Un índice
secundario,AlbumTitleIndex, facilita las consultas por título de álbum.

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.

1. Cree una instancia de la clase DynamoDB.


2. Cree una instancia de la clase CreateTableRequest para proporcionar la información de solicitud.

Versión de API 2012-08-10


624
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

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.

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB dynamoDB = new DynamoDB(client);

String tableName = "Music";

CreateTableRequest createTableRequest = new CreateTableRequest().withTableName(tableName);

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

ArrayList<KeySchemaElement> indexKeySchema = new ArrayList<KeySchemaElement>();


indexKeySchema.add(new
KeySchemaElement().withAttributeName("Artist").withKeyType(KeyType.HASH)); //Partition
key
indexKeySchema.add(new
KeySchemaElement().withAttributeName("AlbumTitle").withKeyType(KeyType.RANGE)); //Sort
key

Projection projection = new Projection().withProjectionType(ProjectionType.INCLUDE);


ArrayList<String> nonKeyAttributes = new ArrayList<String>();
nonKeyAttributes.add("Genre");
nonKeyAttributes.add("Year");
projection.setNonKeyAttributes(nonKeyAttributes);

LocalSecondaryIndex localSecondaryIndex = new LocalSecondaryIndex()

.withIndexName("AlbumTitleIndex").withKeySchema(indexKeySchema).withProjection(projection);

ArrayList<LocalSecondaryIndex> localSecondaryIndexes = new


ArrayList<LocalSecondaryIndex>();
localSecondaryIndexes.add(localSecondaryIndex);

Versión de API 2012-08-10


625
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

createTableRequest.setLocalSecondaryIndexes(localSecondaryIndexes);

Table table = dynamoDB.createTable(createTableRequest);


System.out.println(table.getDescription());

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.

Describir una tabla con un índice secundario local


Para obtener información acerca de los índices secundarios locales en una tabla, utilice la
herramientadescribeTableMétodo de. Para cada índice, puede obtener acceso a su nombre, esquema
de claves y atributos proyectados.

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

1. Cree una instancia de la clase DynamoDB.


2. Cree una instancia de la clase Table. Debe proporcionar el nombre de la tabla.
3. Llame al método describeTable del objeto Table.

En el siguiente ejemplo de código Java se muestran los pasos anteriores.

Example

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB dynamoDB = new DynamoDB(client);

String tableName = "Music";

Table table = dynamoDB.getTable(tableName);

TableDescription tableDescription = table.describe();

List<LocalSecondaryIndexDescription> localSecondaryIndexes
= tableDescription.getLocalSecondaryIndexes();

// This code snippet will work for multiple indexes, even though
// there is only one index in this example.

Iterator<LocalSecondaryIndexDescription> lsiIter = localSecondaryIndexes.iterator();


while (lsiIter.hasNext()) {

LocalSecondaryIndexDescription lsiDescription = lsiIter.next();


System.out.println("Info for index " + lsiDescription.getIndexName() + ":");
Iterator<KeySchemaElement> kseIter = lsiDescription.getKeySchema().iterator();
while (kseIter.hasNext()) {
KeySchemaElement kse = kseIter.next();
System.out.printf("\t%s: %s\n", kse.getAttributeName(), kse.getKeyType());
}
Projection projection = lsiDescription.getProjection();
System.out.println("\tThe projection type is: " + projection.getProjectionType());
if (projection.getProjectionType().toString().equals("INCLUDE")) {
System.out.println("\t\tThe non-key projected attributes are: " +
projection.getNonKeyAttributes());
}
}

Versión de API 2012-08-10


626
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

Consulta de un índice secundario local


Puede utilizarQueryen un índice secundario local de la misma manera queQueryUna tabla de. Debe
especificar el nombre del índice, los criterios de consulta de la clave de ordenación del índice y los
atributos que desea devolver. En este ejemplo, el índice esAlbumTitleIndexy la clave de ordenación del
índice esAlbumTitle.

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

1. Cree una instancia de la clase DynamoDB.


2. Cree una instancia de la clase Table. Debe proporcionar el nombre de la tabla.
3. Cree una instancia de la clase Index. Debe proporcionar el nombre del índice.
4. Llame al método query de la clase Index.

En el siguiente ejemplo de código Java se muestran los pasos anteriores.

Example

AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


DynamoDB dynamoDB = new DynamoDB(client);

String tableName = "Music";

Table table = dynamoDB.getTable(tableName);


Index index = table.getIndex("AlbumTitleIndex");

QuerySpec spec = new QuerySpec()


.withKeyConditionExpression("Artist = :v_artist and AlbumTitle = :v_title")
.withValueMap(new ValueMap()
.withString(":v_artist", "Acme Band")
.withString(":v_title", "Songs About Life"));

ItemCollection<QueryOutcome> items = index.query(spec);

Iterator<Item> itemsIter = items.iterator();

while (itemsIter.hasNext()) {
Item item = itemsIter.next();
System.out.println(item.toJSONPretty());
}

Ejemplo: Índices secundarios locales mediante el API de documentos Java


En el siguiente ejemplo de código Java se muestra cómo usar índices secundarios locales en Amazon
DynamoDB. En el ejemplo, se crea una tabla llamadaCustomerOrderscon una clave de partición
deCustomerIdy una clave de clasificación deOrderId. Hay dos índices secundarios locales en esta
tabla:

• OrderCreationDateIndex: clave de ordenación esOrderCreationDate, y los atributos siguientes


se proyectan en el índice:
• ProductCategory

Versión de API 2012-08-10


627
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

• 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;

public class DocumentAPILocalSecondaryIndexExample {

static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


static DynamoDB dynamoDB = new DynamoDB(client);

Versión de API 2012-08-10


628
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

public static String tableName = "CustomerOrders";

public static void main(String[] args) throws Exception {

createTable();
loadData();

query(null);
query("IsOpenIndex");
query("OrderCreationDateIndex");

deleteTable(tableName);

public static void createTable() {

CreateTableRequest createTableRequest = new


CreateTableRequest().withTableName(tableName)
.withProvisionedThroughput(
new ProvisionedThroughput().withReadCapacityUnits((long)
1).withWriteCapacityUnits((long) 1));

// Attribute definitions for table partition and sort keys


ArrayList<AttributeDefinition> attributeDefinitions = new
ArrayList<AttributeDefinition>();
attributeDefinitions.add(new
AttributeDefinition().withAttributeName("CustomerId").withAttributeType("S"));
attributeDefinitions.add(new
AttributeDefinition().withAttributeName("OrderId").withAttributeType("N"));

// Attribute definition for index primary key attributes


attributeDefinitions
.add(new
AttributeDefinition().withAttributeName("OrderCreationDate").withAttributeType("N"));
attributeDefinitions.add(new
AttributeDefinition().withAttributeName("IsOpen").withAttributeType("N"));

createTableRequest.setAttributeDefinitions(attributeDefinitions);

// Key schema for table


ArrayList<KeySchemaElement> tableKeySchema = new ArrayList<KeySchemaElement>();
tableKeySchema.add(new
KeySchemaElement().withAttributeName("CustomerId").withKeyType(KeyType.HASH)); //
Partition

// key
tableKeySchema.add(new
KeySchemaElement().withAttributeName("OrderId").withKeyType(KeyType.RANGE)); // Sort

// key

createTableRequest.setKeySchema(tableKeySchema);

ArrayList<LocalSecondaryIndex> localSecondaryIndexes = new


ArrayList<LocalSecondaryIndex>();

// OrderCreationDateIndex
LocalSecondaryIndex orderCreationDateIndex = new
LocalSecondaryIndex().withIndexName("OrderCreationDateIndex");

// Key schema for OrderCreationDateIndex


ArrayList<KeySchemaElement> indexKeySchema = new ArrayList<KeySchemaElement>();
indexKeySchema.add(new
KeySchemaElement().withAttributeName("CustomerId").withKeyType(KeyType.HASH)); //
Partition

Versión de API 2012-08-10


629
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

// key
indexKeySchema.add(new
KeySchemaElement().withAttributeName("OrderCreationDate").withKeyType(KeyType.RANGE)); //
Sort

// key

orderCreationDateIndex.setKeySchema(indexKeySchema);

// Projection (with list of projected attributes) for


// OrderCreationDateIndex
Projection projection = new
Projection().withProjectionType(ProjectionType.INCLUDE);
ArrayList<String> nonKeyAttributes = new ArrayList<String>();
nonKeyAttributes.add("ProductCategory");
nonKeyAttributes.add("ProductName");
projection.setNonKeyAttributes(nonKeyAttributes);

orderCreationDateIndex.setProjection(projection);

localSecondaryIndexes.add(orderCreationDateIndex);

// IsOpenIndex
LocalSecondaryIndex isOpenIndex = new
LocalSecondaryIndex().withIndexName("IsOpenIndex");

// Key schema for IsOpenIndex


indexKeySchema = new ArrayList<KeySchemaElement>();
indexKeySchema.add(new
KeySchemaElement().withAttributeName("CustomerId").withKeyType(KeyType.HASH)); //
Partition

// key
indexKeySchema.add(new
KeySchemaElement().withAttributeName("IsOpen").withKeyType(KeyType.RANGE)); // Sort

// key

// Projection (all attributes) for IsOpenIndex


projection = new Projection().withProjectionType(ProjectionType.ALL);

isOpenIndex.setKeySchema(indexKeySchema);
isOpenIndex.setProjection(projection);

localSecondaryIndexes.add(isOpenIndex);

// Add index definitions to CreateTable request


createTableRequest.setLocalSecondaryIndexes(localSecondaryIndexes);

System.out.println("Creating table " + tableName + "...");


System.out.println(dynamoDB.createTable(createTableRequest));

// Wait for table to become active


System.out.println("Waiting for " + tableName + " to become ACTIVE...");
try {
Table table = dynamoDB.getTable(tableName);
table.waitForActive();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}

public static void query(String indexName) {

Versión de API 2012-08-10


630
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

Table table = dynamoDB.getTable(tableName);

System.out.println("\n***********************************************************
\n");
System.out.println("Querying table " + tableName + "...");

QuerySpec querySpec = new


QuerySpec().withConsistentRead(true).withScanIndexForward(true)
.withReturnConsumedCapacity(ReturnConsumedCapacity.TOTAL);

if (indexName == "IsOpenIndex") {

System.out.println("\nUsing index: '" + indexName + "': Bob's orders that are


open.");
System.out.println("Only a user-specified list of attributes are returned\n");
Index index = table.getIndex(indexName);

querySpec.withKeyConditionExpression("CustomerId = :v_custid and IsOpen


= :v_isopen")
.withValueMap(new ValueMap().withString(":v_custid",
"bob@example.com").withNumber(":v_isopen", 1));

querySpec.withProjectionExpression("OrderCreationDate, ProductCategory,
ProductName, OrderStatus");

ItemCollection<QueryOutcome> items = index.query(querySpec);


Iterator<Item> iterator = items.iterator();

System.out.println("Query: printing results...");

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.withKeyConditionExpression("CustomerId = :v_custid and


OrderCreationDate >= :v_orddate")
.withValueMap(
new ValueMap().withString(":v_custid",
"bob@example.com").withNumber(":v_orddate", 20150131));

querySpec.withSelect(Select.ALL_PROJECTED_ATTRIBUTES);

ItemCollection<QueryOutcome> items = index.query(querySpec);


Iterator<Item> iterator = items.iterator();

System.out.println("Query: printing results...");

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

ItemCollection<QueryOutcome> items = table.query(querySpec);

Versión de API 2012-08-10


631
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

Iterator<Item> iterator = items.iterator();

System.out.println("Query: printing results...");

while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}

public static void deleteTable(String tableName) {

Table table = dynamoDB.getTable(tableName);


System.out.println("Deleting table " + tableName + "...");
table.delete();

// Wait for table to be deleted


System.out.println("Waiting for " + tableName + " to be deleted...");
try {
table.waitForDelete();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}

public static void loadData() {

Table table = dynamoDB.getTable(tableName);

System.out.println("Loading data into table " + tableName + "...");

Item item = new Item().withPrimaryKey("CustomerId",


"alice@example.com").withNumber("OrderId", 1)
.withNumber("IsOpen", 1).withNumber("OrderCreationDate",
20150101).withString("ProductCategory", "Book")
.withString("ProductName", "The Great Outdoors").withString("OrderStatus",
"PACKING ITEMS");
// no ShipmentTrackingId attribute

PutItemOutcome putItemOutcome = table.putItem(item);

item = new Item().withPrimaryKey("CustomerId",


"alice@example.com").withNumber("OrderId", 2)
.withNumber("IsOpen", 1).withNumber("OrderCreationDate",
20150221).withString("ProductCategory", "Bike")
.withString("ProductName", "Super Mountain").withString("OrderStatus", "ORDER
RECEIVED");
// no ShipmentTrackingId attribute

putItemOutcome = table.putItem(item);

item = new Item().withPrimaryKey("CustomerId",


"alice@example.com").withNumber("OrderId", 3)
// no IsOpen attribute
.withNumber("OrderCreationDate", 20150304).withString("ProductCategory",
"Music")
.withString("ProductName", "A Quiet Interlude").withString("OrderStatus", "IN
TRANSIT")
.withString("ShipmentTrackingId", "176493");

putItemOutcome = table.putItem(item);

Versión de API 2012-08-10


632
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

item = new Item().withPrimaryKey("CustomerId",


"bob@example.com").withNumber("OrderId", 1)
// no IsOpen attribute
.withNumber("OrderCreationDate", 20150111).withString("ProductCategory",
"Movie")
.withString("ProductName", "Calm Before The Storm").withString("OrderStatus",
"SHIPPING DELAY")
.withString("ShipmentTrackingId", "859323");

putItemOutcome = table.putItem(item);

item = new Item().withPrimaryKey("CustomerId",


"bob@example.com").withNumber("OrderId", 2)
// no IsOpen attribute
.withNumber("OrderCreationDate", 20150124).withString("ProductCategory",
"Music")
.withString("ProductName", "E-Z Listening").withString("OrderStatus",
"DELIVERED")
.withString("ShipmentTrackingId", "756943");

putItemOutcome = table.putItem(item);

item = new Item().withPrimaryKey("CustomerId",


"bob@example.com").withNumber("OrderId", 3)
// no IsOpen attribute
.withNumber("OrderCreationDate", 20150221).withString("ProductCategory",
"Music")
.withString("ProductName", "Symphony 9").withString("OrderStatus", "DELIVERED")
.withString("ShipmentTrackingId", "645193");

putItemOutcome = table.putItem(item);

item = new Item().withPrimaryKey("CustomerId",


"bob@example.com").withNumber("OrderId", 4)
.withNumber("IsOpen", 1).withNumber("OrderCreationDate",
20150222).withString("ProductCategory", "Hardware")
.withString("ProductName", "Extra Heavy Hammer").withString("OrderStatus",
"PACKING ITEMS");
// no ShipmentTrackingId attribute

putItemOutcome = table.putItem(item);

item = new Item().withPrimaryKey("CustomerId",


"bob@example.com").withNumber("OrderId", 5)
/* no IsOpen attribute */
.withNumber("OrderCreationDate", 20150309).withString("ProductCategory",
"Book")
.withString("ProductName", "How To Cook").withString("OrderStatus", "IN
TRANSIT")
.withString("ShipmentTrackingId", "440185");

putItemOutcome = table.putItem(item);

item = new Item().withPrimaryKey("CustomerId",


"bob@example.com").withNumber("OrderId", 6)
// no IsOpen attribute
.withNumber("OrderCreationDate", 20150318).withString("ProductCategory",
"Luggage")
.withString("ProductName", "Really Big Suitcase").withString("OrderStatus",
"DELIVERED")
.withString("ShipmentTrackingId", "893927");

putItemOutcome = table.putItem(item);

item = new Item().withPrimaryKey("CustomerId",


"bob@example.com").withNumber("OrderId", 7)

Versión de API 2012-08-10


633
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

/* 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;
}

Uso de índices secundarios: .NET


Temas
• Creación de una tabla con un índice secundario local (p. 634)
• Describir una tabla con un índice secundario local (p. 636)
• Consulta de un índice secundario local (p. 637)
• Ejemplo: Índices secundarios locales utilizando el parámetroAWS SDK for .NETAPI de bajo
nivel (p. 638)

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.

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree los objetos de solicitud correspondientes para proporcionar los parámetros obligatorios y
opcionales de la operación.

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.

Creación de una tabla con un índice secundario local


Los índices secundarios locales se deben crear a la vez que se crea la tabla. Para ello,
utiliceCreateTabley proporcione las especificaciones para uno o varios índices secundarios locales. En
el siguiente ejemplo de código C# se crea una tabla para contener información sobre las canciones de una
colección de música. La clave de partición esArtisty la clave de ordenación esSongTitle. Un índice
secundario,AlbumTitleIndex, facilita las consultas por título de álbum.

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.

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree una instancia de la clase CreateTableRequest para proporcionar la información de solicitud.

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.

Versión de API 2012-08-10


634
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

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

AmazonDynamoDBClient client = new AmazonDynamoDBClient();


string tableName = "Music";

CreateTableRequest createTableRequest = new CreateTableRequest()


{
TableName = tableName
};

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

tableKeySchema.Add(new KeySchemaElement() { AttributeName = "Artist", KeyType = "HASH" });


//Partition key
tableKeySchema.Add(new KeySchemaElement() { AttributeName = "SongTitle", KeyType =
"RANGE" }); //Sort key

createTableRequest.KeySchema = tableKeySchema;

List<KeySchemaElement> indexKeySchema = new List<KeySchemaElement>();


indexKeySchema.Add(new KeySchemaElement() { AttributeName = "Artist", KeyType = "HASH" });
//Partition key
indexKeySchema.Add(new KeySchemaElement() { AttributeName = "AlbumTitle", KeyType =
"RANGE" }); //Sort key

Projection projection = new Projection() { ProjectionType = "INCLUDE" };

Versión de API 2012-08-10


635
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

List<string> nonKeyAttributes = new List<string>();


nonKeyAttributes.Add("Genre");
nonKeyAttributes.Add("Year");
projection.NonKeyAttributes = nonKeyAttributes;

LocalSecondaryIndex localSecondaryIndex = new LocalSecondaryIndex()


{
IndexName = "AlbumTitleIndex",
KeySchema = indexKeySchema,
Projection = projection
};

List<LocalSecondaryIndex> localSecondaryIndexes = new List<LocalSecondaryIndex>();


localSecondaryIndexes.Add(localSecondaryIndex);
createTableRequest.LocalSecondaryIndexes = localSecondaryIndexes;

CreateTableResponse result = client.CreateTable(createTableRequest);


Console.WriteLine(result.CreateTableResult.TableDescription.TableName);
Console.WriteLine(result.CreateTableResult.TableDescription.TableStatus);

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.

Describir una tabla con un índice secundario local


Para obtener información acerca de los índices secundarios locales en una tabla, utilice la
herramientaDescribeTableAPI. Para cada índice, puede obtener acceso a su nombre, esquema de
claves y atributos proyectados.

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.

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree una instancia de la clase DescribeTableRequest para proporcionar la información de
solicitud. Debe proporcionar el nombre de la tabla.
3. Ejecute ladescribeTableMétodo proporcionando el objeto de solicitud como parámetro.
4.

En el siguiente ejemplo de código C# se ponen en práctica los pasos anteriores.

Example

AmazonDynamoDBClient client = new AmazonDynamoDBClient();


string tableName = "Music";

DescribeTableResponse response = client.DescribeTable(new DescribeTableRequest()


{ TableName = tableName });
List<LocalSecondaryIndexDescription> localSecondaryIndexes =
response.DescribeTableResult.Table.LocalSecondaryIndexes;

// 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 + ":");

foreach (KeySchemaElement kse in lsiDescription.KeySchema)


{
Console.WriteLine("\t" + kse.AttributeName + ": key type is " + kse.KeyType);
}

Versión de API 2012-08-10


636
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

Projection projection = lsiDescription.Projection;

Console.WriteLine("\tThe projection type is: " + projection.ProjectionType);

if (projection.ProjectionType.ToString().Equals("INCLUDE"))
{
Console.WriteLine("\t\tThe non-key projected attributes are:");

foreach (String s in projection.NonKeyAttributes)


{
Console.WriteLine("\t\t" + s);
}

}
}

Consulta de un índice secundario local


Puede usarQueryEn un índice secundario local de un modo bastante similar a como se usaQueryUna
tabla de. Debe especificar el nombre del índice, los criterios de consulta de la clave de ordenación del
índice y los atributos que desea devolver. En este ejemplo, el índice esAlbumTitleIndex, y la clave de
ordenación del índice esAlbumTitle.

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.

1. Cree una instancia de la clase AmazonDynamoDBClient.


2. Cree una instancia de la clase QueryRequest para proporcionar la información de solicitud.
3. Ejecute laqueryMé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.

Example

QueryRequest queryRequest = new QueryRequest


{
TableName = "Music",
IndexName = "AlbumTitleIndex",
Select = "ALL_ATTRIBUTES",
ScanIndexForward = true,
KeyConditionExpression = "Artist = :v_artist and AlbumTitle = :v_title",
ExpressionAttributeValues = new Dictionary<string, AttributeValue>()
{
{":v_artist",new AttributeValue {S = "Acme Band"}},
{":v_title",new AttributeValue {S = "Songs About Life"}}
},
};

QueryResponse response = client.Query(queryRequest);

foreach (var attribs in response.Items)


{
foreach (var attrib in attribs)
{
Console.WriteLine(attrib.Key + " ---> " + attrib.Value.S);

Versión de API 2012-08-10


637
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

}
Console.WriteLine();
}

Ejemplo: Índices secundarios locales utilizando el parámetroAWS SDK


for .NETAPI de bajo nivel
En el siguiente ejemplo de código C# se muestra cómo usar índices secundarios locales en Amazon
DynamoDB. En el ejemplo, se crea una tabla llamadaCustomerOrderscon una clave de partición
deCustomerIdy una clave de clasificación deOrderId. Hay dos índices secundarios locales en esta
tabla:

• OrderCreationDateIndex: clave de ordenación esOrderCreationDate, y los atributos siguientes


se proyectan en el índice:
• ProductCategory
• 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 .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();

Versión de API 2012-08-10


638
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

private static string tableName = "CustomerOrders";

static void Main(string[] args)


{
try
{
CreateTable();
LoadData();

Query(null);
Query("IsOpenIndex");
Query("OrderCreationDateIndex");

DeleteTable(tableName);

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

private static void CreateTable()


{
var createTableRequest =
new CreateTableRequest()
{
TableName = tableName,
ProvisionedThroughput =
new ProvisionedThroughput()
{
ReadCapacityUnits = (long)1,
WriteCapacityUnits = (long)1
}
};

var attributeDefinitions = new List<AttributeDefinition>()


{
// Attribute definitions for table primary key
{ new AttributeDefinition() {
AttributeName = "CustomerId", AttributeType = "S"
} },
{ new AttributeDefinition() {
AttributeName = "OrderId", AttributeType = "N"
} },
// Attribute definitions for index primary key
{ new AttributeDefinition() {
AttributeName = "OrderCreationDate", AttributeType = "N"
} },
{ new AttributeDefinition() {
AttributeName = "IsOpen", AttributeType = "N"
}}
};

createTableRequest.AttributeDefinitions = attributeDefinitions;

// Key schema for table


var tableKeySchema = new List<KeySchemaElement>()
{
{ new KeySchemaElement() {
AttributeName = "CustomerId", KeyType = "HASH"
} }, //Partition key
{ new KeySchemaElement() {
AttributeName = "OrderId", KeyType = "RANGE"
} } //Sort key

Versión de API 2012-08-10


639
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

};

createTableRequest.KeySchema = tableKeySchema;

var localSecondaryIndexes = new List<LocalSecondaryIndex>();

// OrderCreationDateIndex
LocalSecondaryIndex orderCreationDateIndex = new LocalSecondaryIndex()
{
IndexName = "OrderCreationDateIndex"
};

// Key schema for OrderCreationDateIndex


var indexKeySchema = new List<KeySchemaElement>()
{
{ new KeySchemaElement() {
AttributeName = "CustomerId", KeyType = "HASH"
} }, //Partition key
{ new KeySchemaElement() {
AttributeName = "OrderCreationDate", KeyType = "RANGE"
} } //Sort key
};

orderCreationDateIndex.KeySchema = indexKeySchema;

// Projection (with list of projected attributes) for


// OrderCreationDateIndex
var projection = new Projection()
{
ProjectionType = "INCLUDE"
};

var nonKeyAttributes = new List<string>()


{
"ProductCategory",
"ProductName"
};
projection.NonKeyAttributes = nonKeyAttributes;

orderCreationDateIndex.Projection = projection;

localSecondaryIndexes.Add(orderCreationDateIndex);

// IsOpenIndex
LocalSecondaryIndex isOpenIndex
= new LocalSecondaryIndex()
{
IndexName = "IsOpenIndex"
};

// Key schema for IsOpenIndex


indexKeySchema = new List<KeySchemaElement>()
{
{ new KeySchemaElement() {
AttributeName = "CustomerId", KeyType = "HASH"
}}, //Partition key
{ new KeySchemaElement() {
AttributeName = "IsOpen", KeyType = "RANGE"
}} //Sort key
};

// Projection (all attributes) for IsOpenIndex


projection = new Projection()
{
ProjectionType = "ALL"
};

Versión de API 2012-08-10


640
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

isOpenIndex.KeySchema = indexKeySchema;
isOpenIndex.Projection = projection;

localSecondaryIndexes.Add(isOpenIndex);

// Add index definitions to CreateTable request


createTableRequest.LocalSecondaryIndexes = localSecondaryIndexes;

Console.WriteLine("Creating table " + tableName + "...");


client.CreateTable(createTableRequest);
WaitUntilTableReady(tableName);
}

public static void Query(string indexName)


{

Console.WriteLine("\n***********************************************************\n");
Console.WriteLine("Querying table " + tableName + "...");

QueryRequest queryRequest = new QueryRequest()


{
TableName = tableName,
ConsistentRead = true,
ScanIndexForward = true,
ReturnConsumedCapacity = "TOTAL"
};

String keyConditionExpression = "CustomerId = :v_customerId";


Dictionary<string, AttributeValue> expressionAttributeValues = new
Dictionary<string, AttributeValue> {
{":v_customerId", new AttributeValue {
S = "bob@example.com"
}}
};

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;

keyConditionExpression += " and IsOpen = :v_isOpen";


expressionAttributeValues.Add(":v_isOpen", new AttributeValue
{
N = "1"
});

// 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;

keyConditionExpression += " and OrderCreationDate > :v_Date";


expressionAttributeValues.Add(":v_Date", new AttributeValue
{

Versión de API 2012-08-10


641
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

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;

var result = client.Query(queryRequest);


var items = result.Items;
foreach (var currentItem in items)
{
foreach (string attr in currentItem.Keys)
{
if (attr == "OrderId" || attr == "IsOpen"
|| attr == "OrderCreationDate")
{
Console.WriteLine(attr + "---> " + currentItem[attr].N);
}
else
{
Console.WriteLine(attr + "---> " + currentItem[attr].S);
}
}
Console.WriteLine();
}
Console.WriteLine("\nConsumed capacity: " +
result.ConsumedCapacity.CapacityUnits + "\n");
}

private static void DeleteTable(string tableName)


{
Console.WriteLine("Deleting table " + tableName + "...");
client.DeleteTable(new DeleteTableRequest()
{
TableName = tableName
});
WaitForTableToBeDeleted(tableName);
}

public static void LoadData()


{
Console.WriteLine("Loading data into table " + tableName + "...");

Dictionary<string, AttributeValue> item = new Dictionary<string,


AttributeValue>();

item["CustomerId"] = new AttributeValue


{
S = "alice@example.com"
};
item["OrderId"] = new AttributeValue
{
N = "1"
};
item["IsOpen"] = new AttributeValue
{
N = "1"
};
item["OrderCreationDate"] = new AttributeValue
{

Versión de API 2012-08-10


642
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

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 = new Dictionary<string, AttributeValue>();


item["CustomerId"] = new AttributeValue
{
S = "alice@example.com"
};
item["OrderId"] = new AttributeValue
{
N = "2"
};
item["IsOpen"] = new AttributeValue
{
N = "1"
};
item["OrderCreationDate"] = new AttributeValue
{
N = "20130221"
};
item["ProductCategory"] = new AttributeValue
{
S = "Bike"
};
item["ProductName"] = new AttributeValue
{
S = "Super Mountain"
};
item["OrderStatus"] = new AttributeValue
{
S = "ORDER RECEIVED"
};
/* no ShipmentTrackingId attribute */
putItemRequest = new PutItemRequest
{
TableName = tableName,
Item = item,
ReturnItemCollectionMetrics = "SIZE"
};
client.PutItem(putItemRequest);

item = new Dictionary<string, AttributeValue>();


item["CustomerId"] = new AttributeValue
{
S = "alice@example.com"
};

Versión de API 2012-08-10


643
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

item["OrderId"] = new AttributeValue


{
N = "3"
};
/* no IsOpen attribute */
item["OrderCreationDate"] = new AttributeValue
{
N = "20130304"
};
item["ProductCategory"] = new AttributeValue
{
S = "Music"
};
item["ProductName"] = new AttributeValue
{
S = "A Quiet Interlude"
};
item["OrderStatus"] = new AttributeValue
{
S = "IN TRANSIT"
};
item["ShipmentTrackingId"] = new AttributeValue
{
S = "176493"
};
putItemRequest = new PutItemRequest
{
TableName = tableName,
Item = item,
ReturnItemCollectionMetrics = "SIZE"
};
client.PutItem(putItemRequest);

item = new Dictionary<string, AttributeValue>();


item["CustomerId"] = new AttributeValue
{
S = "bob@example.com"
};
item["OrderId"] = new AttributeValue
{
N = "1"
};
/* no IsOpen attribute */
item["OrderCreationDate"] = new AttributeValue
{
N = "20130111"
};
item["ProductCategory"] = new AttributeValue
{
S = "Movie"
};
item["ProductName"] = new AttributeValue
{
S = "Calm Before The Storm"
};
item["OrderStatus"] = new AttributeValue
{
S = "SHIPPING DELAY"
};
item["ShipmentTrackingId"] = new AttributeValue
{
S = "859323"
};
putItemRequest = new PutItemRequest
{
TableName = tableName,

Versión de API 2012-08-10


644
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

Item = item,
ReturnItemCollectionMetrics = "SIZE"
};
client.PutItem(putItemRequest);

item = new Dictionary<string, AttributeValue>();


item["CustomerId"] = new AttributeValue
{
S = "bob@example.com"
};
item["OrderId"] = new AttributeValue
{
N = "2"
};
/* no IsOpen attribute */
item["OrderCreationDate"] = new AttributeValue
{
N = "20130124"
};
item["ProductCategory"] = new AttributeValue
{
S = "Music"
};
item["ProductName"] = new AttributeValue
{
S = "E-Z Listening"
};
item["OrderStatus"] = new AttributeValue
{
S = "DELIVERED"
};
item["ShipmentTrackingId"] = new AttributeValue
{
S = "756943"
};
putItemRequest = new PutItemRequest
{
TableName = tableName,
Item = item,
ReturnItemCollectionMetrics = "SIZE"
};
client.PutItem(putItemRequest);

item = new Dictionary<string, AttributeValue>();


item["CustomerId"] = new AttributeValue
{
S = "bob@example.com"
};
item["OrderId"] = new AttributeValue
{
N = "3"
};
/* no IsOpen attribute */
item["OrderCreationDate"] = new AttributeValue
{
N = "20130221"
};
item["ProductCategory"] = new AttributeValue
{
S = "Music"
};
item["ProductName"] = new AttributeValue
{
S = "Symphony 9"
};
item["OrderStatus"] = new AttributeValue

Versión de API 2012-08-10


645
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

{
S = "DELIVERED"
};
item["ShipmentTrackingId"] = new AttributeValue
{
S = "645193"
};
putItemRequest = new PutItemRequest
{
TableName = tableName,
Item = item,
ReturnItemCollectionMetrics = "SIZE"
};
client.PutItem(putItemRequest);

item = new Dictionary<string, AttributeValue>();


item["CustomerId"] = new AttributeValue
{
S = "bob@example.com"
};
item["OrderId"] = new AttributeValue
{
N = "4"
};
item["IsOpen"] = new AttributeValue
{
N = "1"
};
item["OrderCreationDate"] = new AttributeValue
{
N = "20130222"
};
item["ProductCategory"] = new AttributeValue
{
S = "Hardware"
};
item["ProductName"] = new AttributeValue
{
S = "Extra Heavy Hammer"
};
item["OrderStatus"] = new AttributeValue
{
S = "PACKING ITEMS"
};
/* no ShipmentTrackingId attribute */
putItemRequest = new PutItemRequest
{
TableName = tableName,
Item = item,
ReturnItemCollectionMetrics = "SIZE"
};
client.PutItem(putItemRequest);

item = new Dictionary<string, AttributeValue>();


item["CustomerId"] = new AttributeValue
{
S = "bob@example.com"
};
item["OrderId"] = new AttributeValue
{
N = "5"
};
/* no IsOpen attribute */
item["OrderCreationDate"] = new AttributeValue
{
N = "20130309"

Versión de API 2012-08-10


646
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

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

item = new Dictionary<string, AttributeValue>();


item["CustomerId"] = new AttributeValue
{
S = "bob@example.com"
};
item["OrderId"] = new AttributeValue
{
N = "6"
};
/* no IsOpen attribute */
item["OrderCreationDate"] = new AttributeValue
{
N = "20130318"
};
item["ProductCategory"] = new AttributeValue
{
S = "Luggage"
};
item["ProductName"] = new AttributeValue
{
S = "Really Big Suitcase"
};
item["OrderStatus"] = new AttributeValue
{
S = "DELIVERED"
};
item["ShipmentTrackingId"] = new AttributeValue
{
S = "893927"
};
putItemRequest = new PutItemRequest
{
TableName = tableName,
Item = item,
ReturnItemCollectionMetrics = "SIZE"
};
client.PutItem(putItemRequest);

item = new Dictionary<string, AttributeValue>();


item["CustomerId"] = new AttributeValue
{

Versión de API 2012-08-10


647
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

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

private static void WaitUntilTableReady(string tableName)


{
string status = null;
// Let us wait until table is created. Call DescribeTable.
do
{
System.Threading.Thread.Sleep(5000); // Wait 5 seconds.
try
{
var res = client.DescribeTable(new DescribeTableRequest
{
TableName = tableName
});

Console.WriteLine("Table name: {0}, status: {1}",


res.Table.TableName,
res.Table.TableStatus);
status = res.Table.TableStatus;
}
catch (ResourceNotFoundException)
{
// DescribeTable is eventually consistent. So you might
// get resource not found. So we handle the potential exception.
}
} while (status != "ACTIVE");
}

private static void WaitForTableToBeDeleted(string tableName)


{
bool tablePresent = true;

Versión de API 2012-08-10


648
Amazon DynamoDB Guía para desarrolladores
Índices secundarios locales

while (tablePresent)
{
System.Threading.Thread.Sleep(5000); // Wait 5 seconds.
try
{
var res = client.DescribeTable(new DescribeTableRequest
{
TableName = tableName
});

Console.WriteLine("Table name: {0}, status: {1}",


res.Table.TableName,
res.Table.TableStatus);
}
catch (ResourceNotFoundException)
{
tablePresent = false;
}
}
}
}
}

Uso de índices secundarios:AWS CLI


Puede utilizarAWS CLIPara crear una tabla de Amazon DynamoDB con uno o varios índices secundarios
locales, describir los índices de la tabla y utilizarlos para realizar consultas.

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)

Creación de una tabla con un índice secundario local


Los índices secundarios locales se deben crear a la vez que se crea la tabla. Para ello, utilice lacreate-
tabley proporcione las especificaciones para uno o más índices secundarios locales. En el siguiente
ejemplo se crea una tabla (Music) para contener información sobre las canciones de una colección
de música. La clave de partición esArtisty la clave de ordenación esSongTitle. Un índice
secundario,AlbumTitleIndexen elAlbumTitleEl atributo facilita las consultas por título de álbum.

aws dynamodb create-table \


--table-name Music \
--attribute-definitions AttributeName=Artist,AttributeType=S
AttributeName=SongTitle,AttributeType=S \
AttributeName=AlbumTitle,AttributeType=S \
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
--provisioned-throughput \
ReadCapacityUnits=10,WriteCapacityUnits=5 \
--local-secondary-indexes \
"[{\"IndexName\": \"AlbumTitleIndex\",
\"KeySchema\":[{\"AttributeName\":\"Artist\",\"KeyType\":\"HASH\"},
{\"AttributeName\":\"AlbumTitle\",\"KeyType\":\"RANGE\"}],
\"Projection\":{\"ProjectionType\":\"INCLUDE\", \"NonKeyAttributes\":[\"Genre\",
\"Year\"]}}]"

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.

Versión de API 2012-08-10


649
Amazon DynamoDB Guía para desarrolladores
Uso de secuencias

Describir una tabla con un índice secundario local


Para obtener información acerca de los índices secundarios locales en una tabla, utilice la
herramientadescribe-tableParámetro. Para cada índice, puede obtener acceso a su nombre, esquema
de claves y atributos proyectados.

aws dynamodb describe-table --table-name Music

Consulta de un índice secundario local


Puede utilizarqueryen un índice secundario local de la misma manera quequeryUna tabla de. Debe
especificar el nombre del índice, los criterios de consulta de la clave de ordenación del índice y los
atributos que desea devolver. En este ejemplo, el índice esAlbumTitleIndexy la clave de ordenación del
índice esAlbumTitle.

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

aws dynamodb query \


--table-name Music \
--index-name AlbumTitleIndex \
--key-condition-expression "Artist = :v_artist and AlbumTitle = :v_title" \
--expression-attribute-values '{":v_artist":{"S":"Acme Band"},":v_title":{"S":"Songs
About Life"} }'

Captura de datos de cambio con Amazon


DynamoDB
Muchas aplicaciones se benefician de capturar los cambios en los elementos almacenados en una tabla de
DynamoDB en el momento en que se producen. A continuación se muestran algunos ejemplos de casos
de uso:

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

DynamoDB admite la transmisión de registros de captura de datos de cambio a nivel de elemento en


tiempo casi real. Puede crear aplicaciones que consuman estas secuencias y adopten medidas en función
de su contenido.

Versión de API 2012-08-10


650
Amazon DynamoDB Guía para desarrolladores
Opciones

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)

Opciones de streaming para la captura de datos de


cambio
DynamoDB ofrece dos modelos de transmisión para la captura de datos de cambios: Amazon Kinesis Data
Streams para DynamoDB y DynamoDB Streams.

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.

Properties Kinesis Data Streams para DynamoDB Streams


DynamoDB

Conservación de los datos Hasta1 año. 24 horas.

Compatibilidad con Kinesis Client AdmiteVersiones 1.X y 2.X de AdmiteKCL versión 1.X.
Library (KCL) KCL.

Número de consumidores Hasta5 Hasta2


simultáneosconsumidores simultáneosconsumidores por
por fragmento, o hasta 20 fragmento.
consumidores simultáneos por
fragmento conventilador de
salida mejorado.

Cuotas de rendimiento Sin límite. Sujeto al rendimientoCuotas


depor tabla de DynamoDB
yAWSRegión .

Modelo de entrega de registros Modelo de extracción a través Modelo de extracción a través de


de HTTP utilizandoGetRecordsy HTTP utilizando GetRecords.
conventilador de salida mejorado,
Kinesis Data Streams envía
los registros a través de
HTTP/2 mediante el uso
deSubscribeToShard.

Ordenación de registros El atributo timestamp de cada Para cada elemento que


registro de secuencia se puede se modifica de una tabla de
utilizar para identificar el orden DynamoDB, los registros de
real en el que se produjeron los secuencia aparecen en el mismo
cambios en la tabla DynamoDB. orden en que se han realizado
las modificaciones del elemento.

Registros duplicados Los registros duplicados pueden No aparecen registros duplicados


aparecer ocasionalmente en la en la secuencia.
secuencia.

Opciones de procesamiento de Procesar registros de flujo Procesar registros


secuencias usandoAWS Lambda,Kinesis de flujo usandoAWS
Data Analytics,Kinesis Data

Versión de API 2012-08-10


651
Amazon DynamoDB Guía para desarrolladores
Trabajo con Kinesis Data Streams

Properties Kinesis Data Streams para DynamoDB Streams


DynamoDB
Firehose, o bienAWS GlueETL LambdaorDynamoDB Streams
de streaming. Adapter.

Puede habilitar ambos modelos de transmisión en la misma tabla de DynamoDB.

Cambiar la captura de datos para Kinesis Data


Streams con DynamoDB
Kinesis Data Streams para DynamoDB captura modificaciones a nivel de elemento en cualquier tabla de
DynamoDB y las replica en unFlujos de datos de Kinesisde su elección. Sus aplicaciones pueden acceder
al flujo de datos de Kinesis y ver los cambios a nivel de elemento casi en tiempo real.

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.

Cómo funciona la captura de datos de cambio para Kinesis Data


Streams
Amazon Kinesis Data Streams for Amazon DynamoDB opera de forma asincrónica, por lo que el
desempeño de una tabla no se vea afectado al habilitar una secuencia. Cada vez que se crean, actualizan
o eliminan elementos en la tabla, DynamoDB envía un registro de datos a Kinesis. El registro contiene
información sobre una modificación de datos de un solo elemento de una tabla de DynamoDB. En
concreto, un registro de datos contiene el atributo de clave principal del elemento que se ha modificado y
las imágenes de «antes» y «después» del elemento modificado.

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.

Versión de API 2012-08-10


652
Amazon DynamoDB Guía para desarrolladores
Trabajo con Kinesis Data Streams

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.

Consideraciones sobre la administración de fragmentos para Amazon Kinesis


Data Streams
Afragmentoes la unidad de rendimiento base de una secuencia de datos de Amazon Kinesis. Debe
aprovisionar un número adecuado de fragmentos en su flujo de datos de Kinesis para acomodar los
registros de captura de datos de cambio de DynamoDB.

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:

• El tamaño promedio del registro de su tabla de DynamoDB en bytes


(average_record_size_in_bytes).
• Número máximo de operaciones de escritura que realiza en la tabla de DynamoDB por segundo.
Esto incluye las operaciones de creación, eliminación y actualización de datos realizadas por sus
aplicaciones, así como las operaciones generadas automáticamente, como eliminaciones generadas por
Time to Live (write_throughput).
• El porcentaje de operaciones de actualización y sobreescritura que realiza en la tabla en comparación
con las operaciones de creación o eliminación (percentage_of_updates). Las operaciones de
actualización y sobreescritura replican las imágenes antiguas y nuevas del elemento modificado en la
secuencia, generando así el doble del tamaño del elemento DynamoDB.

Puede aproximar el número de fragmentos (number_of_shards) necesarios para la tabla de DynamoDB


utilizando los valores de entrada de la fórmula siguiente:

Versión de API 2012-08-10


653
Amazon DynamoDB Guía para desarrolladores
Trabajo con Kinesis Data Streams

number_of_shards = ceiling( ((write_throughput * (1+percentage_of_updates) *


average_record_size_in_bytes) /1024 /1024), 1)

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.

Por ejemplo, digamos que tiene un rendimiento máximo de 40 operaciones de escritura/


segundo (write_throughput) con un tamaño promedio de registro de 1285 bytes
(average_record_size_in_bytes). Si el 25% de esas operaciones de escritura son operaciones de
actualización (percentage_of_updates) entonces necesitarás 2 fragmentos (number_of_shards)
para adaptarse a su rendimiento de transmisión de DynamoDB: techo (((40 * (1+25) * 1285)/1024/1024),
1).

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:

• ThrottledPutRecordCount: el número de registros que no se replicaron en el flujo


de datos de Kinesis debido a la capacidad insuficiente del flujo de datos de Kinesis.
LaThrottledPutRecordCountdebe permanecer lo más bajo posible, aunque puede experimentar
cierta limitación durante picos de uso excepcionales. DynamoDB vuelve a intentar poner registros
limitados en el flujo de datos de Kinesis, pero esto podría dar lugar a una mayor latencia de replicación.
Si experimenta una limitación excesiva y regular, es posible que necesite aumentar el número de
fragmentos de secuencias de Kinesis proporcionalmente al rendimiento de escritura observado de la
tabla. 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.
• AgeOfOldestUnreplicatedRecord: el tiempo transcurrido desde el cambio de nivel de elemento
más antiguo que aún no se ha replicado en la secuencia de datos de Kinesis apareció en la tabla de
DynamoDB. En funcionamiento normal,AgeOfOldestUnreplicatedRecorddebe estar en el orden de
milisegundos. Este número crece en función de los intentos de replicación fallidos. DynamoDB reintenta
continuamente los intentos de replicación fallidos cuando se produce un error de replicación. Es posible
que deba ajustar la capacidad del flujo de datos de Kinesis para mantener esta métrica lo más baja
posible.

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

Introducción a Amazon Kinesis Data Streams para Amazon


DynamoDB

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.

Versión de API 2012-08-10


654
Amazon DynamoDB Guía para desarrolladores
Trabajo con Kinesis Data Streams

Todos estos ejemplos utilizan el métodoMusicTabla de DynamoDB creada como parte de laIntroducción a
DynamoDB"Hello, World!"

Console

1. Inicie sesión en laAWS Management Consoley abra la consola de Kinesis en https://


console.aws.amazon.com/kinesis/.
2. SeleccionarCreación de flujo de datosy siga las instrucciones para crear una secuencia
llamadasamplestream.
3. Abra la consola de DynamoDB en https://console.aws.amazon.com/dynamodb/.
4. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas).
5. Elija el iconoMúsicaTabla INTO.
6. Elija el iconoInformación generalPestaña.
7. UNDERDetalles del flujo de datos de Kinesis, elija laAdministrar streaming a Kinesis.

8. SeleccionarsamplestreamEn la lista desplegable.


9. Elija el iconoHabilitarBotón de.

AWS CLI

1. Creación de un flujo de Kinesis llamadosamplestreamMediante lacomando create-stream.

aws kinesis create-stream --stream-name samplestream --shard-count 3

ConsulteConsideraciones sobre la administración de fragmentos para Amazon Kinesis Data


Streams (p. 653)antes de establecer el número de particiones para la secuencia de datos de
Kinesis.
2. Compruebe que la transmisión de Kinesis esté activa y lista para su uso mediante el
comandocomando describe-stream.

aws kinesis describe-stream --stream-name samplestream

3. Habilite la transmisión de Kinesis en la tabla de DynamoDB mediante elenable-kinesis-


streaming-destination. Reemplace el valor de stream-arn con el que fue devuelto
pordescribe-streamEn el paso anterior.

Versión de API 2012-08-10


655
Amazon DynamoDB Guía para desarrolladores
Trabajo con Kinesis Data Streams

aws dynamodb enable-kinesis-streaming-destination \


--table-name Music \
--stream-arn arn:aws:kinesis:us-west-2:123456789012:stream/samplestream

4. Compruebe si la transmisión por secuencias de Kinesis está activa en la tabla mediante el uso de
DynamoDBdescribe-kinesis-streaming-destination.

aws dynamodb describe-kinesis-streaming-destination --table-name Music

5. Escribir datos en la tabla de DynamoDB mediante el comandoput-item, como se describe en el


comandoGuía para desarrolladores de DynamoDB.

aws dynamodb put-item \


--table-name Music \
--item \
'{"Artist": {"S": "No One You Know"}, "SongTitle": {"S": "Call Me Today"},
"AlbumTitle": {"S": "Somewhat Famous"}, "Awards": {"N": "1"}}'

aws dynamodb put-item \


--table-name Music \
--item \
'{"Artist": {"S": "Acme Band"}, "SongTitle": {"S": "Happy Day"},
"AlbumTitle": {"S": "Songs About Life"}, "Awards": {"N": "10"} }'

6. Utilice Kinesisget-recordsComando CLI para recuperar el contenido del flujo Kinesis. A


continuación, utilice el siguiente fragmento de código para deserializar 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 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);
}

private Instant fetchTimestamp(JsonNode dynamoDBRecord) {


JsonNode timestampJson = dynamoDBRecord.get("ApproximateCreationDateTime");
return Instant.ofEpochMilli(timestampJson.longValue());
}

Versión de API 2012-08-10


656
Amazon DynamoDB Guía para desarrolladores
Trabajo con Kinesis Data Streams

Java

1. Siga las instrucciones de la guía para desarrolladores de Kinesis Data Streams paracreateUn flujo
de datos de Kinesis llamadosamplestreamUso de Java.

ConsulteConsideraciones sobre la administración de fragmentos para Amazon Kinesis Data


Streams (p. 653)antes de establecer el número de particiones para la secuencia de datos de
Kinesis.
2. Utilice el siguiente fragmento de código para habilitar Amazon Kinesis Data Streams para Amazon
DynamoDB en la tabla

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

private Instant fetchTimestamp(JsonNode dynamoDBRecord) {


JsonNode timestampJson = dynamoDBRecord.get("ApproximateCreationDateTime");
return Instant.ofEpochMilli(timestampJson.longValue());
}

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.

Versión de API 2012-08-10


657
Amazon DynamoDB Guía para desarrolladores
Trabajo con Kinesis Data Streams

Políticas de IAM personalizadas para Amazon Kinesis Data


Streams para Amazon DynamoDB
La primera vez que habilita Amazon Kinesis Data Streams para Amazon DynamoDB, DynamoDB
crea automáticamente unaAWS Identity and Access Management(IAM) para usted. Esta
función,AWSServiceRoleForDynamoDBKinesisDataStreamsReplication, permite a DynamoDB
administrar la replicación de cambios a nivel de elemento en Kinesis Data Streams en su nombre. No
elimine este rol vinculado a un servicio.

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

Versión de API 2012-08-10


658
Amazon DynamoDB Guía para desarrolladores
Trabajo con Kinesis Data Streams

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

Ejemplo: Aplicación selectiva de permisos para Amazon Kinesis Data Streams


para Amazon DynamoDB basados en recursos
La siguiente política de IAM concede permisos para habilitar y describir Amazon Kinesis Data Streams for
Amazon DynamoDB para elMusicy deniega permisos para deshabilitar Amazon Kinesis Data Streams
para Amazon DynamoDB para elOrdersTabla INTO.

{
"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,

Versión de API 2012-08-10


659
Amazon DynamoDB Guía para desarrolladores
Trabajo con Kinesis Data Streams

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.

La función vinculada al servicio AWSServiceRoleForDynamoDBKinesisDataStreamsReplication


confía en los siguientes servicios para asumir la función:

• 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:

• Acciones:Put records and describeenKinesis stream

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.

Para eliminar manualmente el rol vinculado a un servicio mediante IAM

Versión de API 2012-08-10


660
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

Utilice la consola de IAM, elAWS CLI, o elAWSAPI para eliminar


laAWSServiceRoleForDynamoDBKinesisDataStreamsReplicationFunción vinculada a un servicio.
Para obtener más información, consulte Eliminación de un rol vinculado a servicios en la Guía del usuario
de IAM.

Captura de datos de cambio para DynamoDB Streams


DynamoDB Streams captura una secuencia en orden cronológico de las modificaciones de los elementos
en una tabla de DynamoDB y almacena esta información en un log durante un máximo de 24 horas.
Las aplicaciones pueden obtener acceso a este registro y ver los elementos de datos tal y como se
encontraban antes y después de la modificación, prácticamente en tiempo real.

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 ayuda a garantizar lo siguiente:

• Cada registro de secuencia aparece una única vez en la secuencia.


• Para cada elemento que se modifica de una tabla de DynamoDB, los registros de secuencia aparecen
en el mismo orden en que se han realizado las modificaciones del elemento.

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)

Puntos finales de DynamoDB Streams


AWSmantiene puntos de enlace distintos para DynamoDB y DynamoDB Streams. Para usar las tablas y
los índices de la base de datos, la aplicación debe obtener acceso a un punto de enlace de DynamoDB.
Para leer y procesar los registros de DynamoDB Streams, la aplicación tiene que obtener acceso a un
punto de enlace de DynamoDB Streams situado en la misma región.

La convención de nomenclatura de los puntos de enlace de DynamoDB Streams


esstreams.dynamodb.<region>.amazonaws.com. Por ejemplo, si utiliza el punto de
enlacedynamodb.us-west-2.amazonaws.comPara acceder a DynamoDB, debería utilizar el
extremostreams.dynamodb.us-west-2.amazonaws.comPara acceder a DynamoDB Streams.

Versión de API 2012-08-10


661
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

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.

Habilitación de una secuencia


Puede habilitar una secuencia en una nueva tabla al crearla mediante laAWS CLIo una de lasAWSSDK.
También puede habilitar o deshabilitar una secuencia en una tabla existente, así como cambiar
la configuración de una secuencia. DynamoDB Streams opera de forma asincrónica, por lo que el
desempeño de una tabla no se vea afectado al habilitar una secuencia.

La forma más sencilla de administrar DynamoDB Streams es usar laAWS Management Console.

1. Inicie sesión en laAWS Management Consoley abra la consola de DynamoDB enhttps://


console.aws.amazon.com/dynamodb/.
2. En el panel de la consola de DynamoDB, elijaTablasy seleccione una tabla existente.
3. En la pestaña Overview (Información general), elija Manage Stream (Administrar secuencia).
4. En la ventana Manage Stream (Administrar secuencia), elija la información que se escribirá en la
secuencia cada vez que se modifiquen los datos de la tabla:

• Solo llaves: solo los atributos de clave del elemento modificado.


• New image (Nueva imagen): el elemento completo tal y como aparece después de modificarlo.
• Imagen antigua: el elemento completo tal y como aparecía antes de modificarlo.
• Imágenes nuevas y antiguas: ambas imágenes del elemento, la nueva y la anterior.

Cuando la configuración sea la que desea, elija Enable (Habilitar).


5. (Opcional) Para deshabilitar una secuencia existente, elija Manage Stream (Administrar secuencia) y,
a continuación, seleccione Disable (Deshabilitar).

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

Versión de API 2012-08-10


662
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

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.

Lectura y procesamiento de secuencias


Para leer y procesar una secuencia, la aplicación tiene que conectarse a un punto de enlace de
DynamoDB Streams y emitir solicitudes de API.

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.

Versión de API 2012-08-10


663
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

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:

• Determine el ARN único de la secuencia a la que desea obtener acceso.


• Determine qué fragmentos de la secuencia contienen los registros de secuencia que le interesan.
• Obtenga acceso a los fragmentos y recupere los registros de secuencia que desee.

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:

• ListStreams: devuelve una lista de descriptores de secuencia de la cuenta y el punto de enlace


actuales. Si lo desea, puede solicitar únicamente los descriptores de secuencia de un nombre de tabla
concreto.
• DescribeStream: devuelve información detallada sobre una secuencia determinada. El resultado
incluye una lista de fragmentos asociados a la secuencia, con sus identificadores.
• GetShardIteratorDevuelve.Iterador de fragmentos, que describe una ubicación dentro de un
fragmento. Puede solicitar que el iterador proporcione acceso al punto más antiguo, al punto más
reciente o a un punto concreto de la secuencia.
• GetRecords: devuelve los registros de secuencia de un fragmento determinado. Debe proporcionar el
iterador de fragmentos devuelto por una solicitud GetShardIterator.

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.

Límite de retención de datos en DynamoDB Streams


Todos los datos de DynamoDB Streams están sujetos a una vida útil de 24 horas. Puede recuperar y
analizar las últimas 24 horas de actividad de cada tabla. Sin embargo, los datos de más de 24 horas se
pueden recortar (eliminar) en cualquier momento.

Versión de API 2012-08-10


664
Amazon DynamoDB Guía para desarrolladores
Uso de 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.

DynamoDB Streams y tiempo de vida


Puede realizar copias de seguridad o bien procesar los elementos eliminados porTiempo de
vida (p. 446)(TTTL) habilitando Amazon DynamoDB Streams en la tabla y procesando los registros de
secuencias de los elementos vencidos.

El registro de secuencias contiene el campo de identidad del usuario


Records[<index>].userIdentity.

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"

En el código JSON siguiente se muestra la parte pertinente de un registro de secuencias único.

"Records": [
{
...

"userIdentity": {
"type": "Service",
"principalId": "dynamodb.amazonaws.com"
}

...

}
]

Uso de DynamoDB Streams Kinesis Adapter para procesar


registros de secuencia
Usar Amazon Kinesis Adapter es la forma recomendada de consumir secuencias de Amazon DynamoDB.
DynamoDB Streams API de es intencionadamente similar a la de Kinesis Data Streams, un servicio para
procesar datos de streaming a escala masiva en tiempo real. En ambos servicios, las secuencias de datos
se componen de fragmentos, que son los contenedores de los registros de secuencia. Los API de ambos
servicios contienenListStreams,DescribeStream,GetShards, yGetShardIteratorOperaciones.
Aunque estas acciones de DynamoDB Streams son parecidas a sus homólogas de Kinesis Data Streams,
no son idénticas al 100%.

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

Versión de API 2012-08-10


665
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

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.

En el siguiente diagrama se muestra cómo interaccionan estas bibliotecas entre sí.

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:

Versión de API 2012-08-10


666
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

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

Tutorial: DynamoDB Streams Adapter


En esta sección se recorre paso a paso una aplicación Java en la que se utiliza Amazon Kinesis Client
Library y Amazon DynamoDB Streams Kinesis Adapter. En la aplicación se muestra un ejemplo de
replicación de datos, donde la actividad de escritura de una tabla se aplica a una segunda tabla, de tal
forma que el contenido de ambas se mantiene sincronizado. Para obtener el código fuente, consulte
Programa completo: DynamoDB Streams Adapter (p. 670).

El programa realiza lo siguiente:

1. Crea dos tablas de DynamoDB denominadasKCL-Demo-srcyKCL-Demo-dst. En cada una de estas


tablas se ha habilitado una secuencia.
2. Agrega, actualiza y elimina elementos para generar actividad de actualización en la tabla de origen. Esto
hace que se escriban datos en la secuencia de la tabla.
3. Lee los registros en la secuencia, los reconstruye como solicitudes de DynamoDB y aplica las
solicitudes a la tabla de destino.
4. Examina las tablas de origen y destino para comprobar que sus contenidos sean idénticos.
5. Efectúa una limpieza eliminando las tablas.

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)

Paso 1: Creación de tablas de DynamoDB

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

Versión de API 2012-08-10


667
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

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.

java.util.List<AttributeDefinition> attributeDefinitions = new


ArrayList<AttributeDefinition>();
attributeDefinitions.add(new
AttributeDefinition().withAttributeName("Id").withAttributeType("N"));

java.util.List<KeySchemaElement> keySchema = new ArrayList<KeySchemaElement>();


keySchema.add(new KeySchemaElement().withAttributeName("Id").withKeyType(KeyType.HASH)); //
Partition
//
key

ProvisionedThroughput provisionedThroughput = new


ProvisionedThroughput().withReadCapacityUnits(2L)
.withWriteCapacityUnits(2L);

StreamSpecification streamSpecification = new StreamSpecification();


streamSpecification.setStreamEnabled(true);
streamSpecification.setStreamViewType(StreamViewType.NEW_IMAGE);
CreateTableRequest createTableRequest = new CreateTableRequest().withTableName(tableName)
.withAttributeDefinitions(attributeDefinitions).withKeySchema(keySchema)

.withProvisionedThroughput(provisionedThroughput).withStreamSpecification(streamSpecification);

Paso 2: Generar actividad de actualización en la tabla de origen


El siguiente paso consiste en generar actividad de escritura en la tabla de origen. Mientras tiene lugar esta
actividad, la secuencia de la tabla de origen también se actualiza casi en tiempo real.

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.

StreamsAdapterDemoHelper.putItem(dynamoDBClient, tableName, "101", "test1");


StreamsAdapterDemoHelper.updateItem(dynamoDBClient, tableName, "101", "test2");
StreamsAdapterDemoHelper.deleteItem(dynamoDBClient, tableName, "101");
StreamsAdapterDemoHelper.putItem(dynamoDBClient, tableName, "102", "demo3");
StreamsAdapterDemoHelper.updateItem(dynamoDBClient, tableName, "102", "demo4");
StreamsAdapterDemoHelper.deleteItem(dynamoDBClient, tableName, "102");

Paso 3: Procesar la secuencia


Ahora, el programa comienza a procesar la secuencia. DynamoDB Streams Kinesis Adapter actúa como
una capa transparente entre la KCL y el punto de enlace de DynamoDB Streams, para que el código
pueda utilizar plenamente la KCL, en lugar de tener que realizar llamadas a DynamoDB Streams de bajo
nivel. En el programa se realizan las siguientes tareas:

• Se define una clase de procesador de registros, StreamsRecordProcessor, con métodos que


cumplen con la definición de interfaz de KCL: initialize, processRecords y shutdown. El método
processRecords contiene la lógica necesaria para leer la secuencia de la tabla de origen y escribir en
la tabla de destino.
• Define un generador de clases para la clase de procesador de registros
(StreamsRecordProcessorFactory). Esto es necesario para los programas Java que utilizan la
KCL.

Versión de API 2012-08-10


668
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

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

En el siguiente ejemplo se muestra el bucle principal de StreamsRecordProcessor. La instrucción case


determina qué acción se debe llevar a cabo, según el valor de OperationType que aparece en el registro
de secuencia.

for (Record record : records) {


String data = new String(record.getData().array(), Charset.forName("UTF-8"));
System.out.println(data);
if (record instanceof RecordAdapter) {
com.amazonaws.services.dynamodbv2.model.Record streamRecord =
((RecordAdapter) record)
.getInternalObject();

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

Paso 4: Compruebe que el contenido de ambas tablas es idéntico

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!");
}

Versión de API 2012-08-10


669
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

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

Programa completo: DynamoDB Streams Adapter

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.

Creating table KCL-Demo-src


Creating table KCL-Demo-dest
Table is active.
Creating worker for stream: arn:aws:dynamodb:us-west-2:111122223333:table/KCL-Demo-src/
stream/2015-05-19T22:48:56.601
Starting worker...
Scan result is equal.
Done.

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

El código fuente consta de cuatro archivos .java:

• 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;

Versión de API 2012-08-10


670
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

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;

public class StreamsAdapterDemo {


private static Worker worker;
private static KinesisClientLibConfiguration workerConfig;
private static IRecordProcessorFactory recordProcessorFactory;

private static AmazonDynamoDB dynamoDBClient;


private static AmazonCloudWatch cloudWatchClient;
private static AmazonDynamoDBStreams dynamoDBStreamsClient;
private static AmazonDynamoDBStreamsAdapterClient adapterClient;

private static String tablePrefix = "KCL-Demo";


private static String streamArn;

private static Regions awsRegion = Regions.US_EAST_2;

private static AWSCredentialsProvider awsCredentialsProvider =


DefaultAWSCredentialsProviderChain.getInstance();

/**
* @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();

workerConfig = new KinesisClientLibConfiguration("streams-adapter-demo",


streamArn,
awsCredentialsProvider,
"streams-demo-worker")
.withMaxRecords(1000)
.withIdleTimeBetweenReadsInMillis(500)
.withInitialPositionInStream(InitialPositionInStream.TRIM_HORIZON);

Versión de API 2012-08-10


671
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

System.out.println("Creating worker for stream: " + streamArn);


worker = StreamsWorkerFactory.createDynamoDbStreamsWorker(recordProcessorFactory,
workerConfig, adapterClient, dynamoDBClient, cloudWatchClient);
System.out.println("Starting worker...");
Thread t = new Thread(worker);
t.start();

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

private static void setUpTables() {


String srcTable = tablePrefix + "-src";
String destTable = tablePrefix + "-dest";
streamArn = StreamsAdapterDemoHelper.createTable(dynamoDBClient, srcTable);
StreamsAdapterDemoHelper.createTable(dynamoDBClient, destTable);

awaitTableCreation(srcTable);

performOps(srcTable);
}

private static void awaitTableCreation(String tableName) {


Integer retries = 0;
Boolean created = false;
while (!created && retries < 100) {
DescribeTableResult result =
StreamsAdapterDemoHelper.describeTable(dynamoDBClient, tableName);
created = result.getTable().getTableStatus().equals("ACTIVE");
if (created) {
System.out.println("Table is active.");
return;
}
else {
retries++;
try {
Thread.sleep(1000);
}
catch (InterruptedException e) {
// do nothing
}
}
}
System.out.println("Timeout after table creation. Exiting...");
cleanupAndExit(1);
}

private static void performOps(String tableName) {


StreamsAdapterDemoHelper.putItem(dynamoDBClient, tableName, "101", "test1");
StreamsAdapterDemoHelper.updateItem(dynamoDBClient, tableName, "101", "test2");
StreamsAdapterDemoHelper.deleteItem(dynamoDBClient, tableName, "101");
StreamsAdapterDemoHelper.putItem(dynamoDBClient, tableName, "102", "demo3");

Versión de API 2012-08-10


672
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

StreamsAdapterDemoHelper.updateItem(dynamoDBClient, tableName, "102", "demo4");


StreamsAdapterDemoHelper.deleteItem(dynamoDBClient, tableName, "102");
}

private static void cleanupAndExit(Integer returnValue) {


String srcTable = tablePrefix + "-src";
String destTable = tablePrefix + "-dest";
dynamoDBClient.deleteTable(new DeleteTableRequest().withTableName(srcTable));
dynamoDBClient.deleteTable(new DeleteTableRequest().withTableName(destTable));
System.exit(returnValue);
}
}

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;

public class StreamsRecordProcessor implements IRecordProcessor {


private Integer checkpointCounter;

private final AmazonDynamoDB dynamoDBClient;


private final String tableName;

public StreamsRecordProcessor(AmazonDynamoDB dynamoDBClient2, String tableName) {


this.dynamoDBClient = dynamoDBClient2;
this.tableName = tableName;
}

@Override
public void initialize(InitializationInput initializationInput) {
checkpointCounter = 0;
}

@Override
public void processRecords(ProcessRecordsInput processRecordsInput) {
for (Record record : processRecordsInput.getRecords()) {

Versión de API 2012-08-10


673
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

String data = new String(record.getData().array(), Charset.forName("UTF-8"));


System.out.println(data);
if (record instanceof RecordAdapter) {
com.amazonaws.services.dynamodbv2.model.Record streamRecord =
((RecordAdapter) record)
.getInternalObject();

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.
*/

Versión de API 2012-08-10


674
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

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;

public class StreamsRecordProcessorFactory implements IRecordProcessorFactory {


private final String tableName;
private final AmazonDynamoDB dynamoDBClient;

public StreamsRecordProcessorFactory(AmazonDynamoDB dynamoDBClient, String tableName) {


this.tableName = tableName;
this.dynamoDBClient = dynamoDBClient;
}

@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;

Versión de API 2012-08-10


675
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

import com.amazonaws.services.dynamodbv2.model.UpdateItemRequest;

public class StreamsAdapterDemoHelper {

/**
* @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"));

java.util.List<KeySchemaElement> keySchema = new ArrayList<KeySchemaElement>();


keySchema.add(new
KeySchemaElement().withAttributeName("Id").withKeyType(KeyType.HASH)); // Partition

// key

ProvisionedThroughput provisionedThroughput = new


ProvisionedThroughput().withReadCapacityUnits(2L)
.withWriteCapacityUnits(2L);

StreamSpecification streamSpecification = new StreamSpecification();


streamSpecification.setStreamEnabled(true);
streamSpecification.setStreamViewType(StreamViewType.NEW_IMAGE);
CreateTableRequest createTableRequest = new
CreateTableRequest().withTableName(tableName)
.withAttributeDefinitions(attributeDefinitions).withKeySchema(keySchema)

.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();
}
}

public static DescribeTableResult describeTable(AmazonDynamoDB client, String


tableName) {
return client.describeTable(new DescribeTableRequest().withTableName(tableName));
}

public static ScanResult scanTable(AmazonDynamoDB dynamoDBClient, String tableName) {


return dynamoDBClient.scan(new ScanRequest().withTableName(tableName));
}

public static void putItem(AmazonDynamoDB dynamoDBClient, String tableName, String id,


String val) {
java.util.Map<String, AttributeValue> item = new HashMap<String, AttributeValue>();
item.put("Id", new AttributeValue().withN(id));
item.put("attribute-1", new AttributeValue().withS(val));

PutItemRequest putItemRequest = new


PutItemRequest().withTableName(tableName).withItem(item);
dynamoDBClient.putItem(putItemRequest);
}

public static void putItem(AmazonDynamoDB dynamoDBClient, String tableName,


java.util.Map<String, AttributeValue> items) {

Versión de API 2012-08-10


676
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

PutItemRequest putItemRequest = new


PutItemRequest().withTableName(tableName).withItem(items);
dynamoDBClient.putItem(putItemRequest);
}

public static void updateItem(AmazonDynamoDB dynamoDBClient, String tableName, String


id, String val) {
java.util.Map<String, AttributeValue> key = new HashMap<String, AttributeValue>();
key.put("Id", new AttributeValue().withN(id));

Map<String, AttributeValueUpdate> attributeUpdates = new HashMap<String,


AttributeValueUpdate>();
AttributeValueUpdate update = new
AttributeValueUpdate().withAction(AttributeAction.PUT)
.withValue(new AttributeValue().withS(val));
attributeUpdates.put("attribute-2", update);

UpdateItemRequest updateItemRequest = new


UpdateItemRequest().withTableName(tableName).withKey(key)
.withAttributeUpdates(attributeUpdates);
dynamoDBClient.updateItem(updateItemRequest);
}

public static void deleteItem(AmazonDynamoDB dynamoDBClient, String tableName, String


id) {
java.util.Map<String, AttributeValue> key = new HashMap<String, AttributeValue>();
key.put("Id", new AttributeValue().withN(id));

DeleteItemRequest deleteItemRequest = new


DeleteItemRequest().withTableName(tableName).withKey(key);
dynamoDBClient.deleteItem(deleteItemRequest);
}

API de bajo nivel de DynamoDB Streams: Ejemplo de Java


Note

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:

1. Crea una tabla de DynamoDB con una secuencia habilitada.


2. Describe los ajustes de secuencia de esta tabla.
3. Modifica los datos de la tabla.
4. Describe los fragmentos de la secuencia.
5. Lee los registros de secuencia de los fragmentos.
6. Elimina recursos.

Al ejecutar el programa, verá un resultado parecido al siguiente.

Issuing CreateTable request for TestTableForStreams


Waiting for TestTableForStreams to be created...

Versión de API 2012-08-10


677
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

Current stream ARN for TestTableForStreams: arn:aws:dynamodb:us-east-2:123456789012:table/


TestTableForStreams/stream/2018-03-20T16:49:55.208
Stream enabled: true
Update view type: NEW_AND_OLD_IMAGES

Performing write activities on TestTableForStreams


Processing item 1 of 100
Processing item 2 of 100
Processing item 3 of 100
...
Processing item 100 of 100

Shard: {ShardId: shardId-1234567890-...,SequenceNumberRange: {StartingSequenceNumber:


01234567890...,},}
Shard iterator: EjYFEkX2a26eVTWe...
ApproximateCreationDateTime: Tue Mar 20 09:50:00 PDT 2018,Keys:
{Id={N: 1,}},NewImage: {Message={S: New item!,}, Id={N: 1,}},SequenceNumber:
100000000003218256368,SizeBytes: 24,StreamViewType: NEW_AND_OLD_IMAGES}
{ApproximateCreationDateTime: Tue Mar 20 09:50:00 PDT 2018,Keys: {Id={N:
1,}},NewImage: {Message={S: This item has changed,}, Id={N: 1,}},OldImage:
{Message={S: New item!,}, Id={N: 1,}},SequenceNumber: 200000000003218256412,SizeBytes:
56,StreamViewType: NEW_AND_OLD_IMAGES}
{ApproximateCreationDateTime: Tue Mar 20 09:50:00 PDT 2018,Keys: {Id={N:
1,}},OldImage: {Message={S: This item has changed,}, Id={N: 1,}},SequenceNumber:
300000000003218256413,SizeBytes: 36,StreamViewType: NEW_AND_OLD_IMAGES}
...
Deleting the table...
Demo complete

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;

Versión de API 2012-08-10


678
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

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;

public class StreamsLowLevelDemo {

public static void main(String args[]) throws InterruptedException {

AmazonDynamoDB dynamoDBClient = AmazonDynamoDBClientBuilder


.standard()
.withRegion(Regions.US_EAST_2)
.withCredentials(new DefaultAWSCredentialsProviderChain())
.build();

AmazonDynamoDBStreams streamsClient =
AmazonDynamoDBStreamsClientBuilder
.standard()
.withRegion(Regions.US_EAST_2)
.withCredentials(new DefaultAWSCredentialsProviderChain())
.build();

// Create a table, with a stream enabled


String tableName = "TestTableForStreams";

ArrayList<AttributeDefinition> attributeDefinitions = new ArrayList<>(


Arrays.asList(new AttributeDefinition()
.withAttributeName("Id")
.withAttributeType("N")));

ArrayList<KeySchemaElement> keySchema = new ArrayList<>(


Arrays.asList(new KeySchemaElement()
.withAttributeName("Id")
.withKeyType(KeyType.HASH))); // Partition key

StreamSpecification streamSpecification = new StreamSpecification()


.withStreamEnabled(true)
.withStreamViewType(StreamViewType.NEW_AND_OLD_IMAGES);

CreateTableRequest createTableRequest = new


CreateTableRequest().withTableName(tableName)
.withKeySchema(keySchema).withAttributeDefinitions(attributeDefinitions)
.withProvisionedThroughput(new ProvisionedThroughput()
.withReadCapacityUnits(10L)
.withWriteCapacityUnits(10L))
.withStreamSpecification(streamSpecification);

System.out.println("Issuing CreateTable request for " + tableName);


dynamoDBClient.createTable(createTableRequest);
System.out.println("Waiting for " + tableName + " to be created...");

try {

Versión de API 2012-08-10


679
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

TableUtils.waitUntilActive(dynamoDBClient, tableName);
} catch (AmazonClientException e) {
e.printStackTrace();
}

// Print the stream settings for the table


DescribeTableResult describeTableResult = dynamoDBClient.describeTable(tableName);
String streamArn = describeTableResult.getTable().getLatestStreamArn();
System.out.println("Current stream ARN for " + tableName + ": " +
describeTableResult.getTable().getLatestStreamArn());
StreamSpecification streamSpec =
describeTableResult.getTable().getStreamSpecification();
System.out.println("Stream enabled: " + streamSpec.getStreamEnabled());
System.out.println("Update view type: " + streamSpec.getStreamViewType());
System.out.println();

// Generate write activity in the table

System.out.println("Performing write activities on " + tableName);


int maxItemCount = 100;
for (Integer i = 1; i <= maxItemCount; i++) {
System.out.println("Processing item " + i + " of " + maxItemCount);

// Write a new item


Map<String, AttributeValue> item = new HashMap<>();
item.put("Id", new AttributeValue().withN(i.toString()));
item.put("Message", new AttributeValue().withS("New item!"));
dynamoDBClient.putItem(tableName, item);

// Update the item


Map<String, AttributeValue> key = new HashMap<>();
key.put("Id", new AttributeValue().withN(i.toString()));
Map<String, AttributeValueUpdate> attributeUpdates = new HashMap<>();
attributeUpdates.put("Message", new AttributeValueUpdate()
.withAction(AttributeAction.PUT)
.withValue(new AttributeValue()
.withS("This item has changed")));
dynamoDBClient.updateItem(tableName, key, attributeUpdates);

// Delete the item


dynamoDBClient.deleteItem(tableName, key);
}

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

// Process each shard on this page

for (Shard shard : shards) {


String shardId = shard.getShardId();
System.out.println("Shard: " + shard);

// Get an iterator for the current shard

GetShardIteratorRequest getShardIteratorRequest = new


GetShardIteratorRequest()
.withStreamArn(streamArn)

Versión de API 2012-08-10


680
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

.withShardId(shardId)
.withShardIteratorType(ShardIteratorType.TRIM_HORIZON);
GetShardIteratorResult getShardIteratorResult =
streamsClient.getShardIterator(getShardIteratorRequest);
String currentShardIter = getShardIteratorResult.getShardIterator();

// Shard iterator is not null until the Shard is sealed (marked as


READ_ONLY).
// To prevent running the loop until the Shard is sealed, which will be on
average
// 4 hours, we process only the items that were written into DynamoDB and
then exit.
int processedRecordCount = 0;
while (currentShardIter != null && processedRecordCount < maxItemCount) {
System.out.println(" Shard iterator: " +
currentShardIter.substring(380));

// Use the shard iterator to read the stream records

GetRecordsResult getRecordsResult = streamsClient.getRecords(new


GetRecordsRequest()
.withShardIterator(currentShardIter));
List<Record> records = getRecordsResult.getRecords();
for (Record record : records) {
System.out.println(" " + record.getDynamodb());
}
processedRecordCount += records.size();
currentShardIter = getRecordsResult.getNextShardIterator();
}
}

// If LastEvaluatedShardId is set, then there is


// at least one more page of shard IDs to retrieve
lastEvaluatedShardId =
describeStreamResult.getStreamDescription().getLastEvaluatedShardId();

} while (lastEvaluatedShardId != null);

// Delete the table


System.out.println("Deleting the table...");
dynamoDBClient.deleteTable(tableName);

System.out.println("Demo complete");

}
}

y DynamoDB StreamsAWS LambdaDesencadenadores


Temas
• Tutorial: Procesamiento de nuevos elementos con Amazon DynamoDB Streams y Lambda (p. 682)
• Prácticas recomendadas con Lambda (p. 689)

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.

Versión de API 2012-08-10


681
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

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.

Tutorial: Procesamiento de nuevos elementos con Amazon DynamoDB Streams y


Lambda
Temas
• Paso 1: Crear una tabla de DynamoDB con una secuencia habilitada (p. 683)
• Paso 2: Creación de un rol de ejecución de Lambda (p. 683)
• Paso 3: Creación de un tema de Amazon SNS (p. 685)
• Paso 4: Creación y prueba de una función Lambda (p. 685)
• Paso 5: Creación y prueba de un disparador (p. 688)

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.

Versión de API 2012-08-10


682
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

3. El nuevo registro de secuencia activa una función de AWS Lambda (publishNewBark).


4. Si el registro de flujo indica que se agregó un nuevo elemento aBarkTable, la función Lambda lee los
datos del registro de secuencia y publica un mensaje en un tema de Amazon Simple Notification Service
(Amazon SNS).
5. Los suscriptores a ese tema de Amazon SNS reciben el mensaje. En este tutorial, el único suscriptor es
una dirección de correo electrónico.

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.

Paso 1: Crear una tabla de DynamoDB con una secuencia habilitada

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.

1. Introduzca el siguiente comando para crear la tabla.

aws dynamodb create-table \


--table-name BarkTable \
--attribute-definitions AttributeName=Username,AttributeType=S
AttributeName=Timestamp,AttributeType=S \
--key-schema AttributeName=Username,KeyType=HASH
AttributeName=Timestamp,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
--stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES

2. Busque LatestStreamArn en los resultados.

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

Paso 2: Creación de un rol de ejecución de Lambda

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.

1. Cree un archivo denominado trust-relationship.json con el siguiente contenido.

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {

Versión de API 2012-08-10


683
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}

2. Escriba el siguiente comando para crear WooferLambdaRole.

aws iam create-role --role-name WooferLambdaRole \


--path "/service-role/" \
--assume-role-policy-document file://trust-relationship.json

3. Cree un archivo denominado role-policy.json con el siguiente contenido.


(ReemplaceregionyaccountIDCon tuAWSRegión e identificador de cuenta).

{
"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

• Publicar mensajes en Amazon SNS.


4. Introduzca el siguiente comando para asociar la política al WooferLambdaRole.

aws iam put-role-policy --role-name WooferLambdaRole \


--policy-name WooferLambdaRolePolicy \
--policy-document file://role-policy.json

Paso 3: Creación de un tema de Amazon SNS

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.

1. Introduzca el siguiente comando para crear un nuevo tema de Amazon SNS.

aws sns create-topic --name wooferTopic

2. Introduzca el siguiente comando para suscribir una dirección de correo electrónico a


wooferTopic. (ReemplaceregionyaccountIDCon tuAWSId. de región y cuenta, y
reemplazarexample@example.com).

aws sns subscribe \


--topic-arn arn:aws:sns:region:accountID:wooferTopic \
--protocol email \
--notification-endpoint example@example.com

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.

Paso 4: Creación y prueba de una función Lambda

En este paso, va a crear una función de AWS Lambda (publishNewBark) para procesar los registros de
secuencia de BarkTable.

La función publishNewBark solamente procesa los eventos de la secuencia que corresponden a


elementos nuevos de BarkTable. La función lee los datos de esos eventos y, a continuación, llama a
Amazon SNS para publicarlos.

1. Cree un archivo denominado publishNewBark.js con el siguiente contenido.


ReemplazarregionyaccountIDCon tuAWSId. de cuenta y región.

'use strict';
var AWS = require("aws-sdk");
var sns = new AWS.SNS();

exports.handler = (event, context, callback) => {

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,

Versión de API 2012-08-10


685
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

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.

zip publishNewBark.zip publishNewBark.js

3. Al crear la función Lambda, debe especificar el nombre de recurso de Amazon (ARN)


paraWooferLambdaRole, que creó enPaso 2: Creación de un rol de ejecución de Lambda (p. 683).
Introduzca el siguiente comando para recuperar este ARN.

aws iam get-role --role-name WooferLambdaRole

Busque WooferLambdaRole en los resultados.

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

aws lambda create-function \


--region region \
--function-name publishNewBark \
--zip-file fileb://publishNewBark.zip \
--role roleARN \
--handler publishNewBark.handler \
--timeout 5 \
--runtime nodejs10.x

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.

Cree un archivo denominado payload.json con el siguiente contenido.

{
"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"
}
]
}

Introduzca el siguiente comando para probar la función de publishNewBark.

aws lambda invoke --function-name publishNewBark --payload file://payload.json


output.txt

Si la prueba se realiza correctamente, aparecerá el siguiente resultado.

{
"StatusCode": 200
}

Además, el archivo output.txt contendrá el siguiente texto.

"Successfully processed 1 records."

También recibirá un nuevo mensaje de correo electrónico dentro de unos minutos.


Note

AWS Lambdaescribe la información de diagnóstico en Amazon CloudWatch Logs. Si


se produce cualquier error en la función Lambda, puede utilizar esos diagnósticos para
solucionar el problema:

1. Abra la consola de CloudWatch en https://console.aws.amazon.com/cloudwatch/.


2. En el panel de navegación, elija Logs.
3. Elija el grupo de log siguiente: /aws/lambda/publishNewBark
4. Elija la última secuencia de log para ver el resultado (y los errores) de la función.
Versión de API 2012-08-10
687
Amazon DynamoDB Guía para desarrolladores
Uso de DynamoDB Streams

Paso 5: Creación y prueba de un disparador

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

1. Al crear el disparador, debe especificar el ARN de la secuencia de BarkTable. Introduzca el siguiente


comando para recuperar este ARN.

aws dynamodb describe-table --table-name BarkTable

Busque LatestStreamArn en los resultados.

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

aws lambda create-event-source-mapping \


--region region \
--function-name publishNewBark \
--event-source streamARN \
--batch-size 1 \
--starting-position TRIM_HORIZON

3. Prueba el disparador. Introduzca el siguiente comando para agregar un elemento a BarkTable.

aws dynamodb put-item \


--table-name BarkTable \
--item Username={S="Jane
Doe"},Timestamp={S="2016-11-18:14:32:17"},Message={S="Testing...1...2...3"}

Debería recibir un nuevo mensaje de correo electrónico dentro de unos minutos.


4. Abra la consola de DynamoDB y agregue algunos elementos más aBarkTable. Debe especificar
valores para los atributos Username y Timestamp. También debe especificar un valor para Message,
aunque no es obligatorio. Debe recibir un nuevo mensaje de correo electrónico por cada elemento que
agregue a BarkTable.

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

AWS Lambdaescribe la información de diagnóstico en Amazon CloudWatch Logs. Si se produce


cualquier error en la función Lambda, puede utilizar esos diagnósticos para solucionar el
problema.

1. Abra la consola de CloudWatch en https://console.aws.amazon.com/cloudwatch/.


2. En el panel de navegación, elija Logs.
3. Elija el grupo de log siguiente: /aws/lambda/publishNewBark
4. Elija la última secuencia de log para ver el resultado (y los errores) de la función.

Versión de API 2012-08-10


688
Amazon DynamoDB Guía para desarrolladores
Trabajo con transacciones

Prácticas recomendadas con Lambda


Una función AWS Lambda se ejecuta dentro de un contenedor, a saber, un entorno de ejecución aislado
de las demás funciones. Cuando se ejecuta una función por primera vez, AWS Lambda crea un nuevo
contenedor y comienza a ejecutar el código de la función.

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

Para desencadenadores de DynamoDB usandoAWS Lambda, le recomendamos lo siguiente:

• AWSLos clientes de servicios deben crearse en el código de inicialización, no en el controlador. Esto


permite que AWS Lambda reutilice las conexiones existentes mientras dure la vida útil del contenedor.
• En general, no es necesario administrar de forma explícita las conexiones ni implementar la agrupación
de conexiones, porque AWS Lambda lo hace automáticamente.

Para obtener más información, consultePrácticas recomendadas para trabajar conAWS


LambdaFuncionesen laAWS LambdaGuía para desarrolladores.

Administración de flujos de trabajo complejos con


transacciones de DynamoDB
Las transacciones de Amazon DynamoDB simplifican la experiencia de los desarrolladores de realizar
cambios coordinados de «todo o nada» en varios elementos y distintas tablas. Las transacciones
proporcionan atomicidad, coherencia, aislamiento y durabilidad (ACID, atomicity, consistency, isolation,
and durability) en DynamoDB, lo que le ayuda a mantener la exactitud de los datos en sus aplicaciones.

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

Versión de API 2012-08-10


689
Amazon DynamoDB Guía para desarrolladores
Cómo funciona

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)

Amazon DynamoDB Transactions: Cómo funciona


Con las transacciones de Amazon DynamoDB, puede agrupar varias acciones y enviarlas como un único
«todo o nada»TransactWriteItemsorTransactGetItems. En las secciones siguientes, se describen
las operaciones de la API, la administración de la capacidad, las prácticas recomendadas y otros detalles
sobre el uso de operaciones transaccionales en DynamoDB.

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.

Una operación TransactWriteItems se diferencia de una operación BatchWriteItem en que todas


las acciones que contiene deben completarse correctamente o, de lo contrario, no se realiza ningún
cambio. Con una operación BatchWriteItem, es posible que solo algunas de las acciones del lote se
realicen correctamente y otras, no.

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.

Puede agregar los tipos de acciones siguientes a una transacción:

Versión de API 2012-08-10


690
Amazon DynamoDB Guía para desarrolladores
Cómo funciona

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

Si la llamada a TransactWriteItems original se realizó correctamente, las llamadas siguientes


a TransactWriteItems con el mismo token de cliente también se devolverán correctamente sin
hacer ningún cambio. Si se ha establecido el parámetro ReturnConsumedCapacity, la llamada
TransactWriteItems inicial devolverá el número de unidades de capacidad de escritura consumidas
al realizar los cambios. Las llamadas siguientes a TransactWriteItems con el mismo token de cliente
devolverán el número de unidades de capacidad de lectura consumidas al leer el elemento.

Información importante sobre la idempotencia

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

Control de errores al escribir


Las transacciones de escritura no se realizarán correctamente en las siguientes circunstancias:

• Cuando no se cumple alguna de las condiciones de las expresiones de condición.


• Cuando se produce un error de validación de transacción porque hay más de una acción dirigida al
mismo elemento en una sola operación TransactWriteItems.
• Cuando una solicitud TransactWriteItems está en conflicto con una operación
TransactWriteItems en curso para uno o varios elementos de la solicitud TransactWriteItems.
En este caso, la solicitud genera un error TransactionCanceledException.
• Cuando no hay suficiente capacidad aprovisionada para completar la transacción.
• Cuando el tamaño de un elemento es excesivo (más de 400 KB), un índice secundario local (LSI) se
vuelve demasiado grande o se produce algún error de validación semejante a causa de los cambios
realizados por la transacción.

Versión de API 2012-08-10


691
Amazon DynamoDB Guía para desarrolladores
Cómo funciona

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

Control de errores al leer


Las transacciones de lectura no se realizarán correctamente en las siguientes circunstancias:

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

Niveles de aislamiento para transacciones DynamoDB


Los niveles de aislamiento de las operaciones transaccionales (TransactWriteItems o
TransactGetItems) y otras operaciones son los siguientes.

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.

Existe aislamiento serializable entre los siguientes tipos de operaciones:

• Entre cualquier operación transaccional y cualquier operación de escritura estándar (PutItem,


UpdateItem o DeleteItem).
• Entre cualquier operación transaccional y cualquier operación de lectura estándar (GetItem).
• Entre una operación TransactWriteItems y una operación TransactGetItems.

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.

Versión de API 2012-08-10


692
Amazon DynamoDB Guía para desarrolladores
Cómo funciona

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.

Un soloGetItemes serializable con respecto a unTransactWriteItemsuna de las dos


formas siguientes: antes o después de la propiedad deTransactWriteItemsrequest.
MultipleGetItemsolicitudes, contra claves en unTransactWriteItemsse pueden ejecutar en cualquier
orden, y por lo tanto los resultados sonLectura confirmada.

Por ejemplo, siGetItemlas solicitudes para el elemento A y el elemento B se ejecutan simultáneamente


con unTransactWriteItemsque modifica tanto el punto A como el punto B, hay cuatro posibilidades:

• AmbosGetItemse ejecutan antes de que elTransactWriteItemsrequest.


• AmbosGetItemse ejecutan después de que elTransactWriteItemsrequest.
• GetItempara el elemento A se ejecuta antes de que elTransactWriteItemsrequest. Para el
elemento B, elGetItemse ejecuta después deTransactWriteItems.
• GetItempara el elemento B se ejecuta antes de que elTransactWriteItemsrequest. Para el
elemento A, elGetItemse ejecuta después deTransactWriteItems.

Si se prefiere el nivel de aislamiento serializable para múltiplesGetItem, a continuación,


utiliceTransactGetItems.

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.

El nivel de aislamiento es de lectura confirmada entre cualquier operación transaccional y cualquier


operación de lectura que conlleve varias lecturas estándar (BatchGetItem, Query o Scan). Si una
escritura transaccional actualiza un elemento durante una operación BatchGetItem, Query o Scan, la
operación de lectura devuelve el nuevo valor confirmado.

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.

Operation Nivel de aislamiento

DeleteItem Serializable

PutItem Serializable

UpdateItem Serializable

GetItem Serializable

BatchGetItem Lectura confirmada*

BatchWriteItem NO serializable*

Query Lectura confirmada

Scan Lectura confirmada

Otra operación transaccional Serializable

Versión de API 2012-08-10


693
Amazon DynamoDB Guía para desarrolladores
Cómo funciona

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.

Gestión de conflictos de transacciones en DynamoDB


Un conflicto de transacciones puede producirse durante solicitudes concurrentes de nivel de elemento
en un elemento dentro de una transacción. Los conflictos de transacciones pueden producirse en los
siguientes escenarios:

• 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

• Cuando se rechaza una solicitud PutItem, UpdateItem o DeleteItem, la solicitud no se


realiza correctamente y genera una excepción TransactionConflictException.
• Si se rechaza cualquier solicitud de nivel de elemento dentro de una operación
TransactWriteItems o TransactGetItems, la solicitud no se realiza correctamente y
genera una excepción TransactionCanceledException. Si esa solicitud falla,AWSLos
SDK no vuelven a intentar la solicitud.

Si se está utilizando el AWS SDK for Java, la excepción contiene la lista de


CancellationReasons, ordenada según la lista de elementos del parámetro TransactItems de
la solicitud. Para los demás lenguajes, se incluye una representación de cadena de la lista en el
mensaje de error de la excepción.
• Si una operación TransactWriteItems o TransactGetItems está en conflicto con una
solicitud GetItem concurrente, las dos operaciones podrían realizarse correctamente.

La métrica TransactionConflict de CloudWatch se incrementa para cada solicitud de nivel de elemento que
no se realiza correctamente.

Uso de las API transaccionales en DynamoDB Accelerator (DAX)


TransactWriteItemsyTransactGetItemsTanto como se admiten en el Accelerator de DynamoDB
(DAX) con los mismos niveles de aislamiento que en DynamoDB.

TransactWriteItemsescribe a través de DAX. DAX pasa unTransactWriteItemsLlame


a DynamoDB y devuelve la respuesta. Para rellenar la caché después de la escritura,
DAX llama aTransactGetItemsen segundo plano para cada elemento del cuadro de
textoTransactWriteItemsOperación, que consume unidades de capacidad de lectura adicionales.
(Para obtener más información, consulte Administración de la capacidad para las transacciones (p. 694).)
Esta funcionalidad le permite no complicar la lógica de la aplicación y utilizar DAX para operaciones
transaccionales y no transaccionales.

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.

Administración de la capacidad para las transacciones


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

Versión de API 2012-08-10


694
Amazon DynamoDB Guía para desarrolladores
Cómo funciona

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.

Además, el comportamiento predeterminado del SDK consiste en reintentar las transacciones si se


produce alguna excepción TransactionInProgressException. Planee las unidades de capacidad de
lectura (RCU) adicionales que consumen estos reintentos. Lo mismo sucede si reintenta transacciones de
su propio código mediante un ClientRequestToken.

Prácticas recomendadas para transacciones


Tenga en cuenta las prácticas recomendadas siguientes al utilizar transacciones de DynamoDB.

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

Uso de las API transaccionales con tablas globales


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.

Versión de API 2012-08-10


695
Amazon DynamoDB Guía para desarrolladores
Uso de IAM con transacciones

Biblioteca de clientes de transacciones de DynamoDB


Las transacciones de DynamoDB proporcionan una forma más rentable, robusta y eficiente de sustituir
laAWSLabsBiblioteca de cliente de transacciones. Sugerimos actualizar las aplicaciones de modo que
utilicen las API de transacciones nativas del lado del servidor.

Uso de IAM con transacciones de DynamoDB


Puede usarAWS Identity and Access Management(IAM) para restringir las acciones que las operaciones
transaccionales pueden ejecutar en Amazon DynamoDB. 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).

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.

Ejemplo 1: Permitir las operaciones transaccionales


{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:ConditionCheckItem",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:GetItem"
],
"Resource": [
"arn:aws:dynamodb:*:*:table/table04"
]
}
]
}

Ejemplo 2: Permitir sólo las operaciones transaccionales


{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:ConditionCheckItem",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:GetItem"
],
"Resource": [
"arn:aws:dynamodb:*:*:table/table04"
],

Versión de API 2012-08-10


696
Amazon DynamoDB Guía para desarrolladores
Uso de IAM con transacciones

"Condition": {
"ForAnyValue:StringEquals": {
"dynamodb:EnclosingOperation": [
"TransactWriteItems",
"TransactGetItems"
]
}
}
}
]
}

Ejemplo 3: Permitir las lecturas y escrituras no transaccionales y


bloquear las lecturas y escrituras transaccionales
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"dynamodb:ConditionCheckItem",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:GetItem"
],
"Resource": [
"arn:aws:dynamodb:*:*:table/table04"
],
"Condition": {
"ForAnyValue:StringEquals": {
"dynamodb:EnclosingOperation": [
"TransactWriteItems",
"TransactGetItems"
]
}
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem",
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:UpdateItem"
],
"Resource": [
"arn:aws:dynamodb:*:*:table/table04"
]
}
]
}

Ejemplo 4: Evitar que se devuelva información en caso de error


de ConditionCheck
{
"Version": "2012-10-17",
"Statement": [

Versión de API 2012-08-10


697
Amazon DynamoDB Guía para desarrolladores
Código de ejemplo

{
"Effect": "Allow",
"Action": [
"dynamodb:ConditionCheckItem",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:GetItem"
],
"Resource": "arn:aws:dynamodb:*:*:table/table01",
"Condition": {
"StringEqualsIfExists": {
"dynamodb:ReturnValues": "NONE"
}
}
}
]
}

Ejemplo de transacciones de DynamoDB


Como ejemplo de una situación en la que las transacciones de Amazon DynamoDB pueden ser útiles,
considere esta aplicación Java de ejemplo para un mercado en línea.

La aplicación tiene tres tablas de DynamoDB en el backend:

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

En este ejemplo, configura un pedido de un cliente cuyocustomerIdes09e8e9c8-ec48. A continuación,


se ejecuta como una única transacción mediante el siguiente flujo de trabajo de procesamiento de pedidos:

1. Determine que el ID del cliente sea válido.


2. Asegúrese de que el producto estéIN_STOCKy actualice el estado del producto aSOLD.
3. Asegúrese de que el pedido aún no existe y cree el pedido.

Validar al cliente
Primero, defina una acción para verificar que un cliente concustomerIdigual que09e8e9c8-ec48existe
en la tabla de clientes.

final String CUSTOMER_TABLE_NAME = "Customers";


final String CUSTOMER_PARTITION_KEY = "CustomerId";
final String customerId = "09e8e9c8-ec48";

Versión de API 2012-08-10


698
Amazon DynamoDB Guía para desarrolladores
Código de ejemplo

final HashMap<String, AttributeValue> customerItemKey = new HashMap<>();


customerItemKey.put(CUSTOMER_PARTITION_KEY, new AttributeValue(customerId));

ConditionCheck checkCustomerValid = new ConditionCheck()


.withTableName(CUSTOMER_TABLE_NAME)
.withKey(customerItemKey)
.withConditionExpression("attribute_exists(" + CUSTOMER_PARTITION_KEY + ")");

Actualizar el estado del producto


A continuación, defina una acción para actualizar el estado del producto aSOLDsi la condición en la
que el estado del producto está establecido actualmente enIN_STOCKestrue. Establecimiento del
parámetroReturnValuesOnConditionCheckFailuredevuelve el elemento si el atributo de estado del
producto del artículo no era igual aIN_STOCK.

final String PRODUCT_TABLE_NAME = "ProductCatalog";


final String PRODUCT_PARTITION_KEY = "ProductId";
HashMap<String, AttributeValue> productItemKey = new HashMap<>();
productItemKey.put(PRODUCT_PARTITION_KEY, new AttributeValue(productKey));

Map<String, AttributeValue> expressionAttributeValues = new HashMap<>();


expressionAttributeValues.put(":new_status", new AttributeValue("SOLD"));
expressionAttributeValues.put(":expected_status", new AttributeValue("IN_STOCK"));

Update markItemSold = new Update()


.withTableName(PRODUCT_TABLE_NAME)
.withKey(productItemKey)
.withUpdateExpression("SET ProductStatus = :new_status")
.withExpressionAttributeValues(expressionAttributeValues)
.withConditionExpression("ProductStatus = :expected_status")
.withReturnValuesOnConditionCheckFailure(ReturnValuesOnConditionCheckFailure.ALL_OLD);

Crear el pedido
Por último, cree el pedido siempre y cuando un pedido con eseOrderIdNo existe ya.

final String ORDER_PARTITION_KEY = "OrderId";


final String ORDER_TABLE_NAME = "Orders";

HashMap<String, AttributeValue> orderItem = new HashMap<>();


orderItem.put(ORDER_PARTITION_KEY, new AttributeValue(orderId));
orderItem.put(PRODUCT_PARTITION_KEY, new AttributeValue(productKey));
orderItem.put(CUSTOMER_PARTITION_KEY, new AttributeValue(customerId));
orderItem.put("OrderStatus", new AttributeValue("CONFIRMED"));
orderItem.put("OrderTotal", new AttributeValue("100"));

Put createOrder = new Put()


.withTableName(ORDER_TABLE_NAME)
.withItem(orderItem)
.withReturnValuesOnConditionCheckFailure(ReturnValuesOnConditionCheckFailure.ALL_OLD)
.withConditionExpression("attribute_not_exists(" + ORDER_PARTITION_KEY + ")");

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

Collection<TransactWriteItem> actions = Arrays.asList(


new TransactWriteItem().withConditionCheck(checkCustomerValid),
new TransactWriteItem().withUpdate(markItemSold),

Versión de API 2012-08-10


699
Amazon DynamoDB Guía para desarrolladores
Código de ejemplo

new TransactWriteItem().withPut(createOrder));

TransactWriteItemsRequest placeOrderTransaction = new TransactWriteItemsRequest()


.withTransactItems(actions)
.withReturnConsumedCapacity(ReturnConsumedCapacity.TOTAL);

// Run the transaction and process the result.


try {
client.transactWriteItems(placeOrderTransaction);
System.out.println("Transaction Successful");

} catch (ResourceNotFoundException rnf) {


System.err.println("One of the table involved in the transaction is not found" +
rnf.getMessage());
} catch (InternalServerErrorException ise) {
System.err.println("Internal Server Error" + ise.getMessage());
} catch (TransactionCanceledException tce) {
System.out.println("Transaction Canceled " + tce.getMessage());
}

Leer los detalles del pedido


En el siguiente ejemplo de la se muestra cómo leer la orden completada transaccionalmente en
laOrdersyProductCatalogTablas.

HashMap<String, AttributeValue> productItemKey = new HashMap<>();


productItemKey.put(PRODUCT_PARTITION_KEY, new AttributeValue(productKey));

HashMap<String, AttributeValue> orderKey = new HashMap<>();


orderKey.put(ORDER_PARTITION_KEY, new AttributeValue(orderId));

Get readProductSold = new Get()


.withTableName(PRODUCT_TABLE_NAME)
.withKey(productItemKey);
Get readCreatedOrder = new Get()
.withTableName(ORDER_TABLE_NAME)
.withKey(orderKey);

Collection<TransactGetItem> getActions = Arrays.asList(


new TransactGetItem().withGet(readProductSold),
new TransactGetItem().withGet(readCreatedOrder));

TransactGetItemsRequest readCompletedOrder = new TransactGetItemsRequest()


.withTransactItems(getActions)
.withReturnConsumedCapacity(ReturnConsumedCapacity.TOTAL);

// Run the transaction and process the result.


try {
TransactGetItemsResult result = client.transactGetItems(readCompletedOrder);
System.out.println(result.getResponses());
} catch (ResourceNotFoundException rnf) {
System.err.println("One of the table involved in the transaction is not found" +
rnf.getMessage());
} catch (InternalServerErrorException ise) {
System.err.println("Internal Server Error" + ise.getMessage());
} catch (TransactionCanceledException tce) {
System.err.println("Transaction Canceled" + tce.getMessage());
}

Ejemplos adicionales
• Uso de transacciones de DynamoDBMapper

Versión de API 2012-08-10


700
Amazon DynamoDB Guía para desarrolladores
Trabajo con backups

Backups de DynamoDB
Temas
• Backup bajo demanda y restauración para DynamoDB (p. 701)
• Recuperación a un momento dado para DynamoDB (p. 715)

Backup bajo demanda y restauración para DynamoDB


Puede crear copias de seguridad bajo demanda para sus tablas de Amazon DynamoDB o habilitar copias
de seguridad continuas con recuperación a un momento dado. Para obtener información acerca de
las copias de seguridad continuas con recuperación a un momento dado, consulte 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)

Versión de API 2012-08-10


701
Amazon DynamoDB Guía para desarrolladores
Backup y restauración bajo demanda

Hacer un backup y restaurar tablas de DynamoDB: Cómo


funciona
Puede utilizar la característica de copia de seguridad bajo demanda para crear copias de seguridad
completas de las tablas de Amazon DynamoDB. En esta sección se proporciona información general
acerca de qué ocurre durante los procesos de copia de seguridad y restauración.

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.

Mientras se esté realizando un backup, no puede hacer lo siguiente:

• Pausar o cancelar la operación de backup.


• Eliminar la tabla de origen del backup.
• Deshabilitar los backup de una tabla si uno de ellos está en curso.

Si no desea crear scripts de programación y trabajos de limpieza, puede usarAWS Backuppara


crear planes de copia de seguridad con programaciones y políticas de retención para las tablas de
DynamoDB.AWS Backupejecuta las copias de seguridad y las elimina cuando caducan. Para obtener más
información, consulte AWS Backup Developer Guide.

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:

• Índices secundarios globales (GSI)

Versión de API 2012-08-10


702
Amazon DynamoDB Guía para desarrolladores
Backup y restauración bajo demanda

• Índices secundarios locales (LSI)


• Modo de facturación:
• Capacidad de lectura y escritura aprovisionada
• Configuración de cifrado

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.

Debe configurar manualmente lo siguiente en la tabla que se restaure:

• Políticas de escalado automático


• Políticas de AWS Identity and Access Management (IAM)
• Métricas y alarmas de Amazon CloudWatch
• Etiquetas
• Ajustes de transmisión
• Configuración del período de vida (TTTL)

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.

Copia de seguridad de una tabla de DynamoDB


En esta sección se describe cómo utilizar la consola de Amazon DynamoDB o laAWS Command Line
Interfacepara hacer una copia de seguridad de una tabla.

Versión de API 2012-08-10


703
Amazon DynamoDB Guía para desarrolladores
Backup y restauración bajo demanda

Temas
• Creación de un backup de una tabla (consola) (p. 704)
• Creación de un backup de una tabla (AWS CLI) (p. 705)

Creación de un backup de una tabla (consola)


Siga estos pasos para crear una copia de seguridad con el nombre MusicBackup para una tabla Music
existente con la AWS Management Console.

Para crear una copia de seguridad de tabla

1. Inicie sesión en laAWS Management Consoley abra la consola de DynamoDB enhttps://


console.aws.amazon.com/dynamodb/.
2. Puede crear un backup de las siguientes maneras:

• 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

Si crea backups usando la sección Backups del panel de navegación, la tabla no se


preselecciona automáticamente. Tiene que elegir manualmente el nombre de la tabla de
origen para el backup.

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

Versión de API 2012-08-10


704
Amazon DynamoDB Guía para desarrolladores
Backup y restauración bajo demanda

Creación de un backup de una tabla (AWS CLI)


Siga estos pasos para crear una copia de seguridad de una tabla Music existente con AWS CLI.

Para crear una copia de seguridad de tabla

• Cree una copia de seguridad con el nombre MusicBackup para la tabla Music:

aws dynamodb create-backup --table-name Music \


--backup-name MusicBackup

Mientras se está creando la copia de seguridad, su estado se establece en CREATING:

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

aws dynamodb describe-backup \


--backup-arn arn:aws:dynamodb:us-east-1:123456789012:table/Music/backup/01489173575360-
b308cd7d

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:

aws dynamodb list-backups

El comando list-backups y el comando describe-backup resultan útiles para comprobar información


acerca de la tabla de origen del backup.

Restaurar una tabla de DynamoDB a partir de un Backup


En esta sección se describe cómo restaurar una tabla a partir de un backup mediante la consola de
Amazon DynamoDB o medianteAWS Command Line Interface(AWS CLI).
Note

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)

Versión de API 2012-08-10


705
Amazon DynamoDB Guía para desarrolladores
Backup y restauración bajo demanda

Restaurar una tabla a partir de un backup (consola)


En el siguiente procedimiento se muestra cómo restaurar la tabla Music mediante el archivo
MusicBackup que se creó en el tutorial Copia de seguridad de una tabla de DynamoDB (p. 703).
Note

Este procedimiento asume que la tabla Music ya no existe antes de restaurarla utilizando el
archivo MusicBackup.

Para restaurar una tabla a partir de una copia de seguridad

1. Inicie sesión en laAWS Management Consoley abra la consola de DynamoDB enhttps://


console.aws.amazon.com/dynamodb/.
2. En el panel de navegación del lado izquierdo de la consola, elija Backups.
3. En la lista de backups, elija MusicBackup.

4. Seleccione Restore backup (Restaurar backup).

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

Puede restaurar la tabla a la mismaAWSRegión o a otra región distinta a donde reside la


copia de seguridad. También puede excluir la creación de los índices secundarios en la
nueva tabla restaurada. Además, puede especificar un modo de cifrado diferente.

Versión de API 2012-08-10


706
Amazon DynamoDB Guía para desarrolladores
Backup y restauración bajo demanda

Versión de API 2012-08-10


707
Amazon DynamoDB Guía para desarrolladores
Backup y restauración bajo demanda

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

Restaurar una tabla a partir de un backup (AWS CLI)


Siga estos pasos para utilizar la AWS CLI para restaurar la tabla Music mediante la opción MusicBackup
que se creó en el tutorial Copia de seguridad de una tabla de DynamoDB (p. 703).

Para restaurar una tabla a partir de una copia de seguridad

1. Confirme el backup que quiere restaurar mediante el comando list-backups. En este ejemplo se
utiliza MusicBackup.

aws dynamodb list-backups

Para obtener detalles adicionales del backup, use el comando describe-backup. Puede obtener la
entrada backup-arn del paso anterior.

aws dynamodb describe-backup \


--backup-arn arn:aws:dynamodb:us-east-1:123456789012:table/Music/backup/01489173575360-
b308cd7d

2. Restaure la tabla a partir del backup. En este caso, laMusicBackuprestaura laMusica la misma
tablaAWSRegión .

aws dynamodb restore-table-from-backup \


--target-table-name Music \
--backup-arn arn:aws:dynamodb:us-east-1:123456789012:table/Music/backup/01489173575360-
b308cd7d

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

El parámetro sse-specification-override toma los mismos valores que el parámetro


sse-specification-override utilizado en el comando CreateTable. Para obtener más
información, consulte Administración de tablas de cifrado en DynamoDB (p. 888).

aws dynamodb restore-table-from-backup \


--target-table-name Music \

Versión de API 2012-08-10


708
Amazon DynamoDB Guía para desarrolladores
Backup y restauración bajo demanda

--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 restaurar la tabla a unAWSRegión en la que reside la copia de seguridad.


Note

• El parámetro sse-specification-override es obligatorio para restauraciones entre


regiones, pero opcional para restauraciones en la misma región que la tabla de origen.
• Al realizar una restauración entre regiones desde la línea de comandos, debe establecer el
valor predeterminadoAWSRegión al destino deseado Región. Para obtener más información,
consulteOpciones de la línea de comandosen laAWS Command Line InterfaceGuía del
usuario.

aws dynamodb restore-table-from-backup \


--target-table-name Music \
--backup-arn arn:aws:dynamodb:us-east-1:123456789012:table/Music/backup/01581080476474-
e177ebe2 \
--sse-specification-override Enabled=true,SSEType=KMS

Puede reemplazar el modo de facturación y el rendimiento aprovisionado para la tabla restaurada.

aws dynamodb restore-table-from-backup \


--target-table-name Music \
--backup-arn arn:aws:dynamodb:us-east-1:123456789012:table/Music/backup/01489173575360-
b308cd7d \
--billing-mode-override PAY_PER_REQUEST

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.

aws dynamodb restore-table-from-backup \


--target-table-name Music \
--backup-arn arn:aws:dynamodb:us-east-1:123456789012:table/Music/backup/01581081403719-
db9c1f91 \
--global-secondary-index-override '[]' \
--sse-specification-override Enabled=true,SSEType=KMS

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.

aws dynamodb restore-table-from-backup \


--target-table-name Music \
--backup-arn arn:aws:dynamodb:eu-west-1:123456789012:table/Music/
backup/01581082594992-303b6239 \
Versión de\API 2012-08-10
--billing-mode-override PROVISIONED
709
--provisioned-throughput-override ReadCapacityUnits=100,WriteCapacityUnits=100 \
Amazon DynamoDB Guía para desarrolladores
Backup y restauración bajo demanda

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

aws dynamodb describe-table --table-name 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.

Eliminación de un backup de unta tabla de DynamoDB


En esta sección, se explica cómo utilizar elAWS Management Consoleo elAWS Command Line
Interface(AWS CLI) para eliminar una copia de seguridad de tabla de Amazon DynamoDB.
Note

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)

Eliminación de un backup de una tabla (consola)


El siguiente procedimiento muestra cómo usar la consola para eliminar el archivo MusicBackup que se ha
creado en el tutorial Copia de seguridad de una tabla de DynamoDB (p. 703).

Para eliminar una copia de seguridad

1. Inicie sesión en laAWS Management Consoley abra la consola de DynamoDB enhttps://


console.aws.amazon.com/dynamodb/.
2. En el panel de navegación del lado izquierdo de la consola, elija Backups.
3. En la lista de backups, elija MusicBackup.

Versión de API 2012-08-10


710
Amazon DynamoDB Guía para desarrolladores
Backup y restauración bajo demanda

4. Elija Delete backup (Eliminar backup):

Elija Delete (Eliminar) para eliminar el backup.

Eliminación de un backup de una tabla (AWS CLI)


En el siguiente ejemplo se elimina una copia de seguridad para una tabla existente Music mediante la
AWS CLI.

aws dynamodb delete-backup \


--backup-arn arn:aws:dynamodb:us-east-1:123456789012:table/Music/
backup/01489602797149-73d8d5bc

Versión de API 2012-08-10


711
Amazon DynamoDB Guía para desarrolladores
Backup y restauración bajo demanda

Uso de IAM con Backup y restauración de DynamoDB


Puede usarAWS Identity and Access ManagementPara restringir las acciones de backup y restauración
de Amazon DynamoDB para algunos recursos. Las API CreateBackup y RestoreTableFromBackup
operan para cada tabla.

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.

Ejemplo 1: Permitir las acciones CreateBackup y RestoreTableFromBackup


La siguiente política de IAM concede permisos para permitir
laCreateBackupyRestoreTableFromBackupAcciones de DynamoDB en todas las tablas:

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

Ejemplo 2: Permitir la acción CreateBackup y denegar la acción


RestoreTableFromBackup
La política de IAM siguiente concede permisos para la acción CreateBackup y deniega la acción
RestoreTableFromBackup:

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["dynamodb:CreateBackup"],
"Resource": "*"
},
{
"Effect": "Deny",
"Action": ["dynamodb:RestoreTableFromBackup"],
"Resource": "*"
}

Versión de API 2012-08-10


712
Amazon DynamoDB Guía para desarrolladores
Backup y restauración bajo demanda

]
}

Ejemplo 3: Permitir la acción ListBackups y denegar las acciones CreateBackup y


RestoreTableFromBackup
La política de IAM siguiente concede permisos para la acción ListBackups y deniega las acciones
CreateBackup y RestoreTableFromBackup:

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["dynamodb:ListBackups"],
"Resource": "*"
},
{
"Effect": "Deny",
"Action": [
"dynamodb:CreateBackup",
"dynamodb:RestoreTableFromBackup"
],
"Resource": "*"
}

]
}

Ejemplo 4: Permitir la acción ListBackups denegar la acción DeleteBackup


La política de IAM siguiente concede permisos para la acción ListBackups y deniega la acción
DeleteBackup:

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["dynamodb:ListBackups"],
"Resource": "*"
},
{
"Effect": "Deny",
"Action": ["dynamodb:DeleteBackup"],
"Resource": "*"
}

]
}

Ejemplo 5: Permitir las acciones RestoreTableFromBackup y DescribeBackup


para todos los recursos y denegar la acción DeleteBackup para un Backup
concreto
La política de IAM siguiente concede permisos para
elRestoreTableFromBackupyDescribeBackupacciones y niega elDeleteBackupAcción para un
recurso de copia de seguridad específico:

Versión de API 2012-08-10


713
Amazon DynamoDB Guía para desarrolladores
Backup y restauración bajo demanda

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

Ejemplo 6: Permitir la acción CreateBackup para una tabla concreta


La política de IAM siguiente concede permisos para elCreateBackupen laMoviessólo tabla:

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["dynamodb:CreateBackup"],
"Resource": [
"arn:aws:dynamodb:us-east-1:123456789012:table/Movies"
]
}
]
}

Ejemplo 7: Permitir listBackups


La política de IAM siguiente concede permisos para elListBackupsaction:

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["dynamodb:ListBackups"],
"Resource": "*"
}
]
}

Versión de API 2012-08-10


714
Amazon DynamoDB Guía para desarrolladores
Recuperación a un momento dado

Important

No puede conceder permisos para la acción ListBackups en una tabla concreta.

Recuperación a un momento dado para DynamoDB


Puede crear copias de seguridad bajo demanda de sus tablas de Amazon DynamoDB o habilitar copias
de seguridad continuas mediante la recuperación a un momento dado. Para obtener más información
sobre las copias de seguridad bajo demanda, consulte Backup bajo demanda y restauración para
DynamoDB (p. 701).

La recuperación a un momento dado ayuda a proteger las tablas de DynamoDB de operaciones


accidentales de escritura o eliminación. Al habilitar la recuperación a un momento dado, ya no hay que
preocuparse por crear, mantener o planificar copias de seguridad bajo demanda. Por ejemplo, imaginemos
que un script de prueba escribe accidentalmente en una tabla de DynamoDB. Con la recuperación a un
momento dado, puede restaurar la tabla a cualquier momento de los últimos 35 días. DynamoDB mantiene
backups acumulativos de la tabla.

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

Para obtener más información acerca deAWSDisponibilidad y precios de regiones; consultePrecios de


Amazon DynamoDB.

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)

Recuperación a un momento dado: Cómo funciona


La recuperación a un momento dado (PITR) de Amazon DynamoDB ofrece backups automáticos de los
datos de tablas de DynamoDB. En esta sección se proporciona información general sobre el proceso de
trabajo de DynamoDB.

Puede habilitar la recuperación a un momento dado mediante elAWS Management Console,AWS


Command Line Interface(AWS CLI) o la API de DynamoDB. Una vez habilitada, la recuperación a un
momento dado crea copias de seguridad continuas hasta que la desactive expresamente. Para obtener
más información, consulte Restaurar una tabla de DynamoDB a un momento dado (p. 717).

Después de habilitar la recuperación puntual, puede restaurar a cualquier momento entre


EarliestRestorableDateTime y LatestRestorableDateTime. LatestRestorableDateTime es
normalmente 5 minutos antes de la hora actual.
Note

El proceso de recuperación a un momento dado siempre restaura la información a una tabla


nueva.

En EarliestRestorableDateTime, puede establecer la restauración de la tabla a cualquier momento


de los últimos 35 días. El periodo de retención está fijado en 35 días (cinco semanas naturales) y no se

Versión de API 2012-08-10


715
Amazon DynamoDB Guía para desarrolladores
Recuperación a un momento dado

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:

• Índices secundarios globales (GSI)


• Índices secundarios locales (LSI)
• Modo de facturación:
• Capacidad de lectura y escritura aprovisionada
• Configuración de cifrado

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.

Debe configurar manualmente lo siguiente en la tabla restaurada:

• Políticas de escalado automático


• Políticas de AWS Identity and Access Management (IAM)
• Métricas y alarmas de Amazon CloudWatch
• Etiquetas
• Ajustes de transmisión
• Configuración del período de vida (TTTL)
• Configuración de la recuperación a un momento dado

Versión de API 2012-08-10


716
Amazon DynamoDB Guía para desarrolladores
Recuperación a un momento dado

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

Antes de empezar a usar la recuperación a un momento dado


Antes de habilitar la recuperación a un momento dado (PITR) en una tabla de Amazon DynamoDB, tenga
en cuenta lo siguiente:

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

Restaurar una tabla de DynamoDB a un momento dado


La recuperación a un momento dado (PITR) de Amazon DynamoDB ofrece backups continuos de los datos
de tablas de DynamoDB. Puede restaurar tablas a un momento dado mediante la consola de DynamoDB
o laAWS Command Line Interface(AWS CLI). El proceso de recuperación a un momento dado restaura la
información a una tabla nueva.

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)

Restaurar una tabla a un momento dado (consola)


El siguiente ejemplo ilustra cómo utilizar la consola de DynamoDB para restaurar una tabla
llamadaMusichasta un momento dado.
Note

En este procedimiento se presupone que ha habilitado la recuperación a un momento dado. Para


habilitar esta función en la tabla Music, diríjase a la pestaña Overview (Información general) de

Versión de API 2012-08-10


717
Amazon DynamoDB Guía para desarrolladores
Recuperación a un momento dado

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

Para restaurar una tabla a un momento dado

1. Inicie sesión en laAWS Management Consoley abra la consola de DynamoDB enhttps://


console.aws.amazon.com/dynamodb/.
2. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas).
3. En la lista de tablas, elija la tabla Music.
4. En la pestaña Backups (Copias de seguridad) de la tabla Music, en la sección Point-in-time recovery
(Recuperación a un momento dado), seleccione Restore to point-in-time (Restaurar a un momento
dado).

5. Para el nombre de tabla nuevo, escriba MusicMinutesAgo.


Note

Puede restaurar la tabla a la mismaAWSRegión o a otra región distinta a donde reside la


tabla de origen. También puede excluir la creación de los índices secundarios en la tabla
restaurada. Además, puede especificar un modo de cifrado diferente.
6. Para confirmar el momento de restauración, establezca Restore date and time (Fecha y hora de
restauración) en Latest restore date (Fecha de restauración más reciente). A continuación, elija
Restore table (Restaurar tabla) para iniciar el proceso de restauración.
Note

Puede restaurar a cualquier punto en el tiempo dentro deFecha de restauración más


antiguayÚltima fecha de restauración. DynamoDB restaura los datos de la tabla al estado en
el que se encontraban en la fecha y hora seleccionadas (day:hour:minute:second).

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

Restaurar una tabla a un momento dado (AWS CLI)


En el siguiente procedimiento, se muestra cómo utilizar la AWS CLI para restaurar una tabla llamada
Music a un momento dado.
Note

En este procedimiento se presupone que ha habilitado la recuperación a un momento dado. Para


habilitarlo en la tabla Music, ejecute el siguiente comando.

aws dynamodb update-continuous-backups \


--table-name Music \
--point-in-time-recovery-specification PointInTimeRecoveryEnabled=True

Para restaurar una tabla a un momento dado

1. Para confirmar que la recuperación a un momento dado está habilitada en Music, utilice el comando
describe-continuous-backups.

aws dynamodb describe-continuous-backups \


--table-name Music

Versión de API 2012-08-10


718
Amazon DynamoDB Guía para desarrolladores
Recuperación a un momento dado

Los backups continuos (se habilitan automáticamente al crear la tabla) y la recuperación a un


momento dado están habilitados.

{
"ContinuousBackupsDescription": {
"PointInTimeRecoveryDescription": {
"PointInTimeRecoveryStatus": "ENABLED",
"EarliestRestorableDateTime": 1519257118.0,
"LatestRestorableDateTime": 1520018653.01
},
"ContinuousBackupsStatus": "ENABLED"
}
}

2. Restaure la tabla a un momento dado. En este caso, laMusicse restaura a la


tablaLatestRestorableDateTime(hace ~ 5 minutos) a la mismaAWSRegión .

aws dynamodb restore-table-to-point-in-time \


--source-table-name Music \
--target-table-name MusicMinutesAgo \
--use-latest-restorable-time

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.

aws dynamodb restore-table-to-point-in-time \


--source-table-name Music \
--target-table-name MusicEarliestRestorableDateTime \
--no-use-latest-restorable-time \
--restore-date-time 1519257118.0

Especificar el argumento --no-use-latest-restorable-time es opcional al restaurar


datos a un momento dado específico.
3. Restaure la tabla a un momento en el tiempo con la configuración de tabla personalizada.
En este caso, la tabla Music se restaura a como era en la fecha y hora del valor
LatestRestorableDateTime (hace más o menos 5 minutos).

Puede especificar un modo de cifrado distinto para la tabla restaurada, como se indica a continuación.
Note

El parámetro sse-specification-override toma los mismos valores que el parámetro


sse-specification-override utilizado en el comando CreateTable. Para obtener
más información, consulte Administración de tablas de cifrado en DynamoDB (p. 888).

aws dynamodb restore-table-to-point-in-time \


--source-table-name Music \
--target-table-name MusicMinutesAgo \
--use-latest-restorable-time \
--sse-specification-override Enabled=true,SSEType=KMS,KMSMasterKeyId=abcd1234-
abcd-1234-a123-ab1234a1b234

Puede restaurar la tabla a unAWSRegión de donde reside la tabla de origen.

Versión de API 2012-08-10


719
Amazon DynamoDB Guía para desarrolladores
Recuperación a un momento dado

Note

• El parámetro sse-specification-override es obligatorio para restauraciones entre


regiones, pero opcional para restauraciones en la misma región que la tabla de origen.
• El parámetro source-table-arn debe proporcionarse para restauraciones entre
regiones.
• Al realizar una restauración entre regiones desde la línea de comandos, debe establecer
el valor predeterminadoAWSRegión al destino deseado Región. Para obtener más
información, consulteOpciones de la línea de comandosen laAWS Command Line
InterfaceGuía del usuario.

aws dynamodb restore-table-to-point-in-time \


--source-table-arn arn:aws:dynamodb:us-east-1:123456789012:table/Music \
--target-table-name MusicMinutesAgo \
--use-latest-restorable-time \
--sse-specification-override Enabled=true,SSEType=KMS,KMSMasterKeyId=abcd1234-
abcd-1234-a123-ab1234a1b234

Puede reemplazar el modo de facturación y el rendimiento aprovisionado para la tabla restaurada.

aws dynamodb restore-table-to-point-in-time \


--source-table-name Music \
--target-table-name MusicMinutesAgo \
--use-latest-restorable-time \
--billing-mode-override PAY_PER_REQUEST

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.

aws dynamodb restore-table-to-point-in-time \


--source-table-name Music \
--target-table-name MusicMinutesAgo \
--use-latest-restorable-time \
--global-secondary-index-override '[]'

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.

aws dynamodb restore-table-to-point-in-time \


--source-table-name Music \
--target-table-name MusicMinutesAgo \
--billing-mode-override PROVISIONED \
--provisioned-throughput-override ReadCapacityUnits=100,WriteCapacityUnits=100 \
--global-secondary-index-override IndexName=singers-
index,KeySchema=["{AttributeName=SingerName,KeyType=HASH}"],Projection="{ProjectionType=KEYS_ONLY}"
\
--sse-specification-override Enabled=true,SSEType=KMS \
--use-latest-restorable-time

Versión de API 2012-08-10


720
Amazon DynamoDB Guía para desarrolladores
Recuperación a un momento dado

Para comprobar la restauración, use el comando describe-table para describir la tabla


MusicEarliestRestorableDateTime.

aws dynamodb describe-table --table-name MusicEarliestRestorableDateTime

La tabla que se va a restaurar se muestra con el estado Creating (Creando) y el valor de


restauración en curso true. Una vez finalizado el proceso de restauración, el estado de la tabla
MusicEarliestRestorableDateTime cambia a Active (Activa).
Important

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.

Versión de API 2012-08-10


721
Amazon DynamoDB Guía para desarrolladores

Accelerator en memoria con


DynamoDB Accelerator (DAX)
Amazon DynamoDB está diseñado para facilitar el escalado y mejorar el desempeño. En la mayoría
de los casos, los tiempos de respuesta de DynamoDB pueden medirse en milisegundos con cifras de
un solo dígito. No obstante, existen determinados casos de uso que requieren tiempos de respuesta
en microsegundos. Para estos casos de uso, DynamoDB Accelerator (DAX) proporciona tiempos de
respuesta más breves de acceso a datos de consistencia final.

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)

Versión de API 2012-08-10


722
Amazon DynamoDB Guía para desarrolladores
Casos de uso de DAX

• Cifrado de DAX en tránsito (p. 826)


• Uso de roles de IAM vinculados a servicios para DAX (p. 827)
• Acceso a DAX a través deAWSCuentas (p. 830)
• Guía de tamaño de clúster de DAX (p. 837)
• Referencia de la API de (p. 839)

Casos de uso de DAX


DAX proporciona acceso a datos de consistencia final de tablas de DynamoDB con una latencia de
microsegundos. Un clúster de DAX que abarque varias zonas de disponibilidad puede atender millones de
solicitudes por segundo.

DAX es ideal para los siguientes tipos de aplicaciones:

• 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é.

DAX esnoes ideal para los siguientes tipos de aplicaciones:

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

Notas de uso de DAX


• Para obtener una lista deAWSRegiones en las que DAX está disponible, consultePrecios de Amazon
DynamoDB.

Versión de API 2012-08-10


723
Amazon DynamoDB Guía para desarrolladores
Cómo funciona

• 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"
}

DAX: Cómo funciona


El acelerador de Amazon DynamoDB (DAX) está diseñado para ejecutarse en un entorno de Amazon
Virtual Private Cloud (Amazon VPC). El servicio Amazon VPC define una red virtual que se parece mucho
a un centro de datos tradicional. Con una VPC, puede controlar el rango de direcciones IP, las subredes,
las tablas de ruteo, las gateways de red y los ajustes de seguridad. Puede lanzar un clúster de DAX en la
red virtual y controlar el acceso al clúster mediante grupos de seguridad de Amazon VPC.
Note

Si ha creado suAWSDespués del 4 de diciembre de 2013, ya tiene una VPC predeterminada en


cadaAWSRegión . La VPC está lista para usarse de inmediato, sin tener que realizar ningún paso
de configuración adicional.
Para obtener más información, consulteVPC predeterminada y subredes predeterminadasen
laGuía del usuario de Amazon VPC.

En el siguiente diagrama se muestra información general sobre DAX.

Versión de API 2012-08-10


724
Amazon DynamoDB Guía para desarrolladores
Cómo procesa DAX las solicitudes

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.

Por último, el clúster de DAX devuelve los resultados a la aplicación.

Temas
• Cómo procesa DAX las solicitudes (p. 725)
• Caché de elementos (p. 727)
• Caché de consultas (p. 727)

Cómo procesa DAX las solicitudes


Un clúster de DAX consta de uno o varios nodos. Cada nodo ejecuta su propia instancia del software de
almacenamiento en caché de DAX. Uno de los nodos sirve como nodo principal del clúster. Los nodos
adicionales (en caso de incluirse) actúan como réplicas de lectura. Para obtener más información, consulte
Nodes (p. 728).

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

Versión de API 2012-08-10


725
Amazon DynamoDB Guía para desarrolladores
Cómo procesa DAX las solicitudes

• BatchGetItem
• Query
• Scan

Si la solicitud especificalecturas consistentes finales(el comportamiento predeterminado), intenta leer el


elemento de DAX:

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

Si la solicitud especificalecturas de coherencia altaDAX transmite la solicitud a DynamoDB. Los resultados


de DynamoDB no se almacenan en caché en DAX. Sencillamente, se devuelven a la aplicación.

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 detallada sobre la coherencia de DAX y DynamoDB, consulteModelos de


consistencia DAX y DynamoDB (p. 741).

Para obtener información sobre el funcionamiento de las transacciones en DAX, consulteUso de las API
transaccionales en DynamoDB Accelerator (DAX) (p. 694).

Limitación de velocidad de solicitudes


Si el número de solicitudes enviadas a DAX supera la capacidad de un nodo, DAX limita la velocidad a
la que acepta solicitudes adicionales devolviendo unaThrottlingException. DAX evalúa continuamente la
utilización de la CPU para determinar el volumen de solicitudes que puede procesar manteniendo el clúster
en buen estado.

Versión de API 2012-08-10


726
Amazon DynamoDB Guía para desarrolladores
Caché de elementos

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

Puede especificar el ajuste de TL de la caché de elementos 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 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.

Si especifica cero comocaché de elementosTTL, los elementos de la caché de elementos solo se


actualizarán debido a una expulsión de LRU o a una «escritura».

Para obtener información detallada sobre la coherencia de la caché de elementos en DAX,


consulteComportamiento de la caché de elementos de (p. 741).

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

Versión de API 2012-08-10


727
Amazon DynamoDB Guía para desarrolladores
Componentes de los clústeres

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.

Si especifica cero comocaché de consultasTTL, la respuesta de la consulta no se almacenará en caché.

Para obtener información detallada sobre la coherencia de la caché de consultas en DAX,


consulteComportamiento de la caché de consultas de (p. 744).

Componentes de los clústeres


Un clúster de de Amazon DynamoDB Accelerator (DAX) consta deAWScomponentes de la infraestructura
En esta sección se describen estos componentes y cómo funcionan entre sí.

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.

Puede escalar el clúster de de de una de las dos formas siguientes:

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

Versión de API 2012-08-10


728
Amazon DynamoDB Guía para desarrolladores
Regiones y zonas de disponibilidad

El nodo principal es responsable de lo siguiente:

• Responder a las solicitudes de datos en caché que formulan las aplicaciones.


• Transmitir las operaciones de escritura a DynamoDB.
• Expulsar los datos de la caché, de acuerdo con la política de expulsión del clúster.

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.

Las réplicas de lectura son responsables de lo siguiente:

• Responder a las solicitudes de datos en caché que formulan las aplicaciones.


• Expulsar los datos de la caché, de acuerdo con la política de expulsión del clúster.

Sin embargo, al contrario que el nodo principal, las réplicas de lectura no escriben en DynamoDB.

Las réplicas de lectura cumplen dos funciones adicionales:

• 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é.

Regiones y zonas de disponibilidad


Un clúster DAX en unAWSLa región solo puede interaccionar con las tablas de DynamoDB que se
encuentran en esa misma región. Por este motivo, debe asegurarse de lanzar el clúster de DAX en la
región correcta. Si tiene tablas de DynamoDB en otras regiones, debe lanzar clústeres de DAX en ellas
también.

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.

Versión de API 2012-08-10


729
Amazon DynamoDB Guía para desarrolladores
Grupos de parámetros

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 del clúster


A cada clúster DAX se le asigna unNombre de recurso de Amazon(ARN). El formato del ARN es el
siguiente.

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

Punto de enlace de clúster


Todos los clústeres DAX proporcionan unPunto de enlace de clústerPara su uso en su aplicación de. Al
obtener acceso al clúster a través de este punto de enlace, la aplicación no tiene que conocer los nombres
de los hosts ni los números de los puertos de los nodos individuales del clúster. Su aplicación "conoce"
automáticamente todos los nodos del clúster, aunque se agreguen o eliminen réplicas de lectura.

A continuación, se muestra un ejemplo de punto de enlace de un clúster en la región de us-east-1 que no


está configurado para utilizar el cifrado en tránsito.

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.

Versión de API 2012-08-10


730
Amazon DynamoDB Guía para desarrolladores
Puntos de enlace de nodos

daxs://my-encrypted-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com

Puntos de enlace de nodos


Cada uno de los nodos individuales de un clúster de DAX tiene su propio nombre de host y número de
puerto. A continuación, se muestra un ejemplo de punto de enlace de un nodo.

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.

Maintenance Window (Período de mantenimiento)


Cada clúster tiene un periodo de mantenimiento semanal durante el que se aplican los cambios del
sistema. Si no especifica un período de mantenimiento preferido al crear o modificar un clúster de caché,
DAX asigna un período de mantenimiento de 60 minutos un día de la semana seleccionado al azar.

La ventana de mantenimiento de 60 minutos se selecciona al azar dentro de un bloque de 8 horas


porAWSRegión . En la siguiente tabla, se muestran los bloques de tiempo de cada región desde los que se
asignan los periodos predeterminados de mantenimiento.

Código de región Nombre de la región Maintenance Window

ap-northeast-1 Asia Pacific (Tokyo) Region 13:00 — 21:00 UTC

ap-southeast-1 Asia Pacific (Singapore) Region 14:00 — 22:00

ap-southeast-2 Asia Pacific (Sydney) Region 12:00 — 20:00

Versión de API 2012-08-10


731
Amazon DynamoDB Guía para desarrolladores
Creación de Cluster de DAX

Código de región Nombre de la región Maintenance Window

ap-south-1 Asia Pacific (Mumbai) Region 17:30 — 1:30

cn-northwest-1 Región China (Ningxia) 23:00 — 07:00 UTC

eu-central-1 Europe (Frankfurt) Region 23:00 — 07:00 UTC

eu-west-1 Europe (Ireland) Region 22:00 — 06:00 UTC

eu-west-2 Europe (London) Region 23:00 — 07:00 UTC

eu-west-3 Región de Europa (París) 23:00 — 07:00 UTC

sa-east-1 South America (São Paulo) 01:00 — 09:00 UTC


Region

us-east-1 US East (N. Virginia) Region 03:00 — 11:00 UTC

us-east-2 US East (Ohio) Region 23:00 — 07:00 UTC

us-west-1 US West (N. California) Region 06:00 — 14:00 UTC

us-west-2 US West (Oregon) Region 06:00 — 14:00 UTC

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.

Creación de Cluster de DAX


En esta sección se lleva a cabo paso a paso el proceso de configuración y uso de Amazon DynamoDB
Accelerator (DAX) por primera vez en el entorno de Amazon Virtual Private Cloud (Amazon VPC)
predeterminado. Puede crear su primer clúster de DAX mediante laAWS Command Line Interface(AWS
CLI) o elAWS Management Console.

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)

Creación de un rol de servicio de IAM para que DAX


obtenga acceso a DynamoDB
Para que su clúster de DAX obtenga acceso a las tablas de DynamoDB en su nombre, debe crear
unaRol de servicio de. Un rol de servicio es unAWS Identity and Access ManagementEl rol de (IAM) de
de deAWSPara actuar en su nombre. El rol de servicio permite a DAX obtener acceso a las tablas de
DynamoDB como si usted estuviese abriéndolas directamente. Debe crear el rol de servicio para poder
crear el clúster de DAX.

Versión de API 2012-08-10


732
Amazon DynamoDB Guía para desarrolladores
Creación de un rol de servicio de IAM para
que DAX obtenga acceso a DynamoDB

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

Permisos necesarios para crear un rol de servicio


La administrada de AWSAdministratorAccessproporciona todos los permisos que se necesitan para
crear un clúster de DAX y un rol de servicio. Si su usuario de IAM tieneAdministratorAccessadjunto,
no tiene que hacer nada más.

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

Asocie estos permisos al usuario que intenta realizar la acción.


Note

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.

Si aparece este mensaje de error... Haga lo siguiente:

User: Agregue iam:CreateRole a la política de


arn:aws:iam::accountID:user/userName usuario.
is not authorized to perform:
iam:CreateRole on resource:
arn:aws:iam::accountID:role/service-
role/roleName

User: Agregue iam:CreatePolicy a la política de


arn:aws:iam::accountID:user/userName usuario.
is not authorized to perform:
iam:CreatePolicy on resource: policy
policyName

User: Agregue iam:AttachRolePolicy a la política de


arn:aws:iam::accountID:user/userName usuario.

Versión de API 2012-08-10


733
Amazon DynamoDB Guía para desarrolladores
Mediante AWS CLI

Si aparece este mensaje de error... Haga lo siguiente:


is not authorized to perform:
iam:AttachRolePolicy on resource: role
daxServiceRole

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

Creación de clústeres de DAX mediante laAWS CLI


En esta sección se describe cómo crear un clúster de Amazon DynamoDB (DAX) mediante laAWS
Command Line Interface(AWS CLI). Si aún no lo ha hecho, debe instalar y configurar la AWS CLI. Para
ello, consulte las siguientes instrucciones en laAWS Command Line InterfaceGuía del usuario:

• Instalación de la AWS CLI


• Configuración d AWS CLI

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)

Paso 1: Cree un rol de servicio de IAM para que DAX obtenga


acceso a DynamoDB mediante laAWS CLI
Para poder crear un clúster de Amazon DynamoDB (DAX), antes debe crear un rol de servicio para este
clúster. ARol de servicio dees unAWS Identity and Access ManagementEl rol de (IAM) de de deAWSPara
actuar en su nombre. El rol de servicio permite a DAX obtener acceso a las tablas de DynamoDB como si
usted estuviese abriéndolas directamente.

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.

Para crear un rol de servicio de IAM para DAX

1. Cree un archivo denominado service-trust-relationship.json con el siguiente contenido.

{
"Version": "2012-10-17",
"Statement": [
{

Versión de API 2012-08-10


734
Amazon DynamoDB Guía para desarrolladores
Mediante AWS CLI

"Effect": "Allow",
"Principal": {
"Service": "dax.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}

2. Cree el rol de servicio.

aws iam create-role \


--role-name DAXServiceRoleForDynamoDBAccess \
--assume-role-policy-document file://service-trust-relationship.json

3. Cree un archivo denominado service-role-policy.json con el siguiente contenido.

{
"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:*"
]
}
]
}

ReemplazaraccountIDcon suAWSID de la cuenta de. Para buscar suAWSEn la esquina superior


derecha de la consola, elija su ID de inicio de sesión. SusAWSEl ID de la cuenta de ID aparece en el
menú desplegable.

En el nombre de recurso de Amazon (ARN) en el ejemplo, accountID debe ser un número de 12


dígitos. No utilice guiones ni ningún otro signo de puntuación.
4. Cree una política de IAM para el rol de servicio.

aws iam create-policy \


--policy-name DAXServicePolicyForDynamoDBAccess \
--policy-document file://service-role-policy.json

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.

aws iam attach-role-policy \

Versión de API 2012-08-10


735
Amazon DynamoDB Guía para desarrolladores
Mediante AWS CLI

--role-name DAXServiceRoleForDynamoDBAccess \
--policy-arn arn

A continuación, especifique un grupo de subredes para su VPC predeterminada. Un grupo de subredes


es una colección de una o varias subredes de la VPC. Consulte Paso 2: Creación de un grupo de
subredes (p. 736).

Paso 2: Creación de un grupo de subredes


Siga este procedimiento para crear un grupo de subredes para su clúster de Amazon DynamoDB (DAX)
mediante laAWS Command Line Interface(AWS CLI).
Note

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.

Para crear un grupo de subredes

1. Para determinar el identificador de la VPC predeterminada, introduzca el siguiente comando.

aws ec2 describe-vpcs

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.

aws ec2 describe-subnets \


--filters "Name=vpc-id,Values=vpcID" \
--query "Subnets[*].SubnetId"

En el resultado, anote los identificadores de subred (por ejemplo,subnet-11111111.


3. Cree el grupo de subredes. Asegúrese de especificar al menos un ID de subred en el parámetro --
subnet-ids.

aws dax create-subnet-group \


--subnet-group-name my-subnet-group \
--subnet-ids subnet-11111111 subnet-22222222 subnet-33333333 subnet-44444444

Para crear el clúster, consulte Paso 3: Cree un clúster de DAX mediante laAWS CLI (p. 736).

Paso 3: Cree un clúster de DAX mediante laAWS CLI


Siga este procedimiento para utilizar laAWS Command Line Interface(AWS CLI) para crear un clúster de
Amazon DynamoDB (DAX) en la Amazon VPC predeterminada.

Para crear un clúster de DAX

1. Obtenga el nombre de recurso de Amazon (ARN) del rol de servicio.

Versión de API 2012-08-10


736
Amazon DynamoDB Guía para desarrolladores
Mediante AWS CLI

aws iam get-role \


--role-name DAXServiceRoleForDynamoDBAccess \
--query "Role.Arn" --output text

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.

aws dax create-cluster \


--cluster-name mydaxcluster \
--node-type dax.r4.large \
--replication-factor 3 \
--iam-role-arn roleARN \
--subnet-group my-subnet-group \
--sse-specification Enabled=true \
--region us-west-2

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.

Para ver el estado del clúster, introduzca el siguiente comando.

aws dax describe-clusters

El estado se muestra en la salida, por ejemplo,"Status": "creating".


Note
La creación del clúster tarda varios minutos. Cuando el clúster esté listo, su estado cambiará a
available. Mientras tanto, continúe con Paso 4: Configure las reglas de entrada del grupo de
seguridad mediante laAWS CLI (p. 737) y siga las instrucciones que se facilitan.

Paso 4: Configure las reglas de entrada del grupo de seguridad


mediante laAWS CLI
Los nodos del clúster de Amazon DynamoDB (DAX) utilizan el grupo de seguridad predeterminado de
Amazon VPC. Para el grupo de seguridad predeterminado, tendrá que autorizar el tráfico entrante en el
puerto TCP 8111 para los clústeres no cifrados o el puerto 9111 para los clústeres cifrados. Esto permitirá
que las instancias Amazon EC2 de su Amazon VPC obtengan acceso a su clúster de DAX.
Note
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.

Para configurar las reglas de entrada del grupo de seguridad

1. Para determinar el identificador del grupo de seguridad predeterminado, introduzca el siguiente


comando. Sustituya vpcID por el ID de la VPC real (de Paso 2: Creación de un grupo de
subredes (p. 736)).

Versión de API 2012-08-10


737
Amazon DynamoDB Guía para desarrolladores
Mediante la consola

aws ec2 describe-security-groups \


--filters Name=vpc-id,Values=vpcID,Name=group-name,Values=default \
--query "SecurityGroups[*].{GroupName:GroupName,GroupId:GroupId}"

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.

aws ec2 authorize-security-group-ingress \


--group-id sgID --protocol tcp --port 8111

Creación de clústeres de DAX mediante laAWS


Management Console
En esta sección se describe cómo crear un clúster de Amazon DynamoDB (DAX) mediante laAWS
Management Console.

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)

Paso 1: Cree un grupo de subredes mediante laAWS


Management Console
Siga este procedimiento para crear un grupo de subredes para su clúster de Amazon DynamoDB (DAX)
mediante laAWS Management Console.
Note

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.

Para crear un grupo de subredes

1. Abra la consola de DynamoDB en https://console.aws.amazon.com/dynamodb/.


2. En el panel de navegación, elija DAX.
3. Elija Create subnet group (Crear grupo de subredes).
4. En la ventana Create subnet group (Crear grupo de subredes), haga lo siguiente:

a. Nombre: escriba el nombre corto del grupo de subredes.


b. Descripción: escriba una descripción del grupo de subredes.

Versión de API 2012-08-10


738
Amazon DynamoDB Guía para desarrolladores
Mediante la consola

c. ID DE LA VPC: elija el identificador del entorno de Amazon VPC.


d. Subredes: elija una o varias subredes de la lista.
Note

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

Paso 2: Cree un clúster de DAX mediante laAWS Management


Console
Siga este procedimiento para crear un clúster de Amazon DynamoDB (DAX) en la Amazon VPC
predeterminada.

Para crear un clúster de DAX

1. Abra la consola de DynamoDB en https://console.aws.amazon.com/dynamodb/.


2. En el panel de navegación, en DAX, elija Clusters (Clústeres).
3. Elija Create cluster.
4. En la ventana Create cluster (Crear clúster), haga lo siguiente:

a. Cluster name (Nombre del clúster): escriba el nombre corto del clúster de DAX.
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.
b. Descripción del clúster: escriba una descripción del clúster.
c. Tipo de nodo: elija el tipo de nodo de todos los nodos del clúster.
d. Tamaño del clúster: elija el número de nodos del clúster. Un clúster consta de un nodo principal y
hasta nueve réplicas de lectura.
Note

Si desea crear un clúster de un solo nodo, elija 1. Su clúster constará de un nodo


principal.
Si desea crear un clúster de varios nodos, elija un número entre 3 (una instancia principal
y dos réplicas de lectura) y 10 (una instancia principal y 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.

Versión de API 2012-08-10


739
Amazon DynamoDB Guía para desarrolladores
Mediante la consola

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

En la páginaClústeresEn la pantalla, aparecerá el clúster de DAX con el estadoCrear.


Note

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.

Paso 3: Configure las reglas de entrada del grupo de seguridad


mediante laAWS Management Console
El clúster de Acelerador de Amazon DynamoDB (DAX) se comunica a través del puerto TCP 8111 (para
clústeres no cifrados) o 9111 (para clústeres cifrados), así que debe autorizar el tráfico entrante en ese
puerto. Esto permitirá que las instancias Amazon EC2 de su Amazon VPC obtengan acceso a su clúster de
DAX.
Note

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.

Para configurar las reglas de entrada del grupo de seguridad

1. Abra la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/.


2. En el panel de navegación, elija Security Groups.

Versión de API 2012-08-10


740
Amazon DynamoDB Guía para desarrolladores
Modelo de consistencia

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

Fuente: introduzcapredeterminaday, a continuación, elija el identificador del grupo de seguridad


predeterminado.

Cuando la configuración sea la que desea, elija Save (Guardar).

Modelos de consistencia DAX y DynamoDB


El acelerador de Amazon DynamoDB (DAX) es un servicio de almacenamiento en caché de escritura
indirecta (write-through), diseñado para simplificar el proceso de agregar una caché a las tablas de
DynamoDB. Dado que DAX funciona por separado de DynamoDB, es importante comprender los modelos
de consistencia de DAX y de DynamoDB para conseguir que sus aplicaciones se comporten como se
espera de ellas.

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)

Consistencia entre los nodos de los clúst


Para dotar de alta disponibilidad a la aplicación, recomendamos aprovisionar el clúster de DAX con al
menos tres nodos. A continuación, coloque los nodos en varias zonas de disponibilidad de una región.

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.

Comportamiento de la caché de elementos de


Cada clúster de DAX tiene dos memorias caché diferentes, unaelementocaché y una solicitudquerycaché.
Para obtener más información, consulte DAX: Cómo funciona (p. 724).

Versión de API 2012-08-10


741
Amazon DynamoDB Guía para desarrolladores
Comportamiento de la caché de elementos de

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.

El elemento permanece en la caché de elementos DAX, de conformidad con la configuración de tiempo de


vida (TTL) y el algoritmo usado menos recientemente (LRU) de la caché. Para obtener más información,
consulte DAX: Cómo funciona (p. 724).

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.

Versión de API 2012-08-10


742
Amazon DynamoDB Guía para desarrolladores
Comportamiento de la caché de elementos de

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

Además deGetItem, el cliente DAX también admiteBatchGetItemsolicitudes.


BatchGetItemEn esencia, es un encapsulador alrededor de uno o variosGetItemLas
solicitudes, de modo que DAX trata cada una de ellas como una solicitud individualGetItem.

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

Procesamiento de escrituras en DAX


DAX está pensado para aplicaciones que requieren las lecturas de alto desempeño. Como caché
de escritura, DAX pasa las escrituras a DynamoDB de forma sincrónica y, a continuación, replica de
forma automática y asíncrona las actualizaciones resultantes a la caché de elementos en todos los
nodos del clúster. No es necesario administrar la lógica de invalidación de caché, porque DAX lo hace
automáticamente.

DAX admite las siguientes operaciones de escritura:


PutItem,UpdateItem,DeleteItem,BatchWriteItem, yTransactWriteItems.

Cuando envía unPutItem,UpdateItem,DeleteItem, o bienBatchWriteItemEn DAX, ocurriría lo


siguiente:

• DAX envía la solicitud a DynamoDB.


• DynamoDB responde a DAX para confirmar que la escritura se ha llevado a cabo correctamente.
• DAX escribe el elemento en su caché de elementos.
• DAX devuelve al solicitante que la escritura se ha realizado correctamente.

Cuando envía unTransactWriteItemsEn DAX, ocurriría lo siguiente:

• DAX envía la solicitud a DynamoDB.


• DynamoDB responde a DAX para confirmar que la transacción se ha completado.
• DAX devuelve al solicitante que la escritura se ha realizado correctamente.
• En segundo plano, DAX crea unTransactGetItemspara cada elemento en
elTransactWriteItemsrequest para almacenar el elemento en la caché de elementos.
TransactGetItemsse utiliza para garantizaraislamiento serializable (p. 692).

Versión de API 2012-08-10


743
Amazon DynamoDB Guía para desarrolladores
Comportamiento de la caché de consultas de

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.

Comportamiento de la caché de consultas de


DAX almacena en caché los resultados deQueryyScanrequest en su caché de consultas. Sin embargo,
estos resultados no afectan en absoluto a la caché de elementos. Cuando su aplicación emite unQueryo
bienScansolicitud con DAX, el conjunto de resultados se guarda en la caché de consultas, no en la caché
de elementos. No se puede "calentar" la caché de elementos antes de llevar a cabo una operación Scan,
ya que la caché de elementos y la caché de consultas son entidades independientes.

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

En este caso, el conjunto de resultados almacenado en caché correspondiente a la operación Query


emitida en el paso 3 es idéntico al que se almacenó en caché en el paso 1. La razón es que DAX no
invalidaQueryo bienScanconjuntos de resultados basados en actualizaciones de elementos individuales.
LaPutItemoperación del paso 2 solo se refleja en la caché de consultas de DAX cuando el TTL de la
solicitudQueryExpires.

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.

Lecturas transaccionales y de consistencia alta


Para realizar una operación deGetItem,BatchGetItem,Query, o bienScan, establece la
solicitudConsistentReadtrue. DAX pasa las solicitudes de consistencia alta a DynamoDB. Cuando
recibe una respuesta de DynamoDB, DAX devuelve los resultados al cliente, pero no almacena en caché
los resultados. DAX no puede atender por sí solo a las lecturas de consistencia alta, porque no está
estrechamente acoplado a DynamoDB. Debido a esto, todas las lecturas posteriores de DAX tendrían que
ser lecturas consistentes finales, Y las lecturas de consistencia alta posteriores tendrían que pasarse a
través de DynamoDB.

Controladores DAXTransactGetItemssolicita la misma manera que administra las lecturas de


consistencia alta. DAX pasa todos losTransactGetItemssolicitudes a DynamoDB. Cuando recibe
una respuesta de DynamoDB, DAX devuelve los resultados al cliente, pero no almacena en caché los
resultados.

Versión de API 2012-08-10


744
Amazon DynamoDB Guía para desarrolladores
Almacenamiento en caché negativo

Almacenamiento en caché negativo


DAX admite las entradas de caché negativas, tanto en la caché de elementos como en la caché de
consultas. AEntrada de caché negativaCuando DAX no encuentra los elementos solicitados en una tabla
de DynamoDB subyacente. En lugar de generar un error, DAX almacena en caché un resultado vacío y se
lo devuelve al usuario.

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

Versión de API 2012-08-10


745
Amazon DynamoDB Guía para desarrolladores
Estrategias de escritura

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.

1. Alice actualiza un elemento enProductCatalogTabla INTO DAX reenvía la solicitud a DynamoDB


y la actualización se lleva a cabo correctamente. Después, DAX escribe el elemento en su caché de
elementos y devuelve una respuesta correcta a Alice. A partir de ese momento, hasta que el elemento
se expulse definitivamente de la caché, cualquier usuario que lo lea en DAX verá el elemento con la
actualización de Alice.
2. Poco después, Bob actualiza el mismo elemento ProductCatalog en el que Alice ha escrito. Sin
embargo, Bob actualiza el elemento directamente en DynamoDB. DAX no actualiza automáticamente su
caché de elementos en respuesta a las actualizaciones a través de DynamoDB. Por tanto, los usuarios
de DAX no ven la actualización de Bob.
3. Alice vuelve a leer el elemento en DAX. El elemento se encuentra en la caché de elementos, por lo que
DAX se lo devuelve a Alice sin obtener acceso a la tabla de 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

Versión de API 2012-08-10


746
Amazon DynamoDB Guía para desarrolladores
Desarrollo con el cliente de DAX

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.

Desarrollo de DynamoDB Accelerator (DAX)


Para utilizar DAX desde una aplicación, use el cliente de DAX para su lenguaje de programación. El cliente
DAX se ha diseñado de tal forma que se minimicen las interrupciones para las aplicaciones de Amazon
DynamoDB existentes; solo se necesitan algunas modificaciones sencillas en el código.
Note

Los clientes de DAX para diversos lenguajes de programación están disponibles en el siguiente
sitio:

Versión de API 2012-08-10


747
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

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

Tutorial: Ejecución de una aplicación de ejemplo de


utilizando DynamoDB Accelerator (DAX)
En este tutorial se muestra cómo lanzar una instancia de Amazon EC2 en la nube virtual privada (VPC)
predeterminada, conectarse a la instancia y ejecutar una aplicación de ejemplo que utiliza Amazon
DynamoDB Accelerator (DAX).
Note

Para completar este tutorial, debe disponer de un clúster de DAX en ejecución en la


VPC predeterminada. Si no ha creado un clúster DAX, consulteCreación de Cluster de
DAX (p. 732)Para obtener instrucciones, consulte.

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)

Paso 1: Lanzamiento de una instancia de Amazon EC2


Una vez que el clúster de Amazon DynamoDB Accelerator (DAX) esté disponible, puede lanzar una
instancia Amazon EC2 en la Amazon VPC predeterminada. A continuación, puede instalar y ejecutar el
software cliente de DAX en dicha instancia.

Para lanzar una instancia EC2

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:

Paso 1: Elegir una imagen de máquina de Amazon (AMI)

1. En la lista de AMI, busque la Amazon Linux AMI (AMI de Amazon Linux) y elija Select (Seleccionar).

Paso 2: Página Choose an Instance Type

1. En la lista de tipos de instancias, elija t2.micro.


2. Seleccione Next (Siguiente): Página Configure Instance Details (Configurar los detalles de la
instancia).

Versión de API 2012-08-10


748
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

Paso 3: Página Configure Instance Details (Configurar los detalles de la instancia)

1. En Network (Red), seleccione su VPC predeterminada.


2. Seleccione Next (Siguiente): Adición de almacenamiento.

Paso 4: Adición de almacenamiento

1. Elija para omitir este pasoSiguiente: Añadir etiquetas.

Paso 5: Añadir etiquetas

1. Elija para omitir este pasoSiguiente: Página Configure Security Group (Configurar grupo de
seguridad).

Paso 6: Página Configure Security Group (Configurar grupo de seguridad)

1. Elija Select an existing security group.


2. En la lista de grupos de seguridad, elija default. Se trata del grupo de seguridad predeterminado
para la VPC.
3. Seleccione Next (Siguiente): Review and Launch.

Paso 7: Página Review Instance Launch (Revisar lanzamiento de instancia)

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.

Paso 2: Crear un usuario y una política de IAM


En este paso, creará unAWS Identity and Access Management(IAM) que dispone de una política que
concede acceso al clúster de Amazon DynamoDB Accelerator (DAX) y a DynamoDB. A continuación,
puede ejecutar aplicaciones que interaccionen con el clúster de DAX.

Versión de API 2012-08-10


749
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

Para crear un usuario y una política de IAM

1. Abra la consola de IAM en https://console.aws.amazon.com/iam/.


2. En el panel de navegación, seleccione Users.
3. Elija Add user.
4. En la página Details (Detalles), escriba la siguiente información:

• User name (Nombre de usuario):: introduzca un nombre único; por ejemplo,:MyDAXUser.


• Tipo de acceso—ElijaAcceso programático.

Seleccione Next (Siguiente): Permisos.


5. En la página Set permissions (Establecer permisos), elija Attach existing policies directly (Asociar
directamente las políticas existentes) y después Create policy (Crear política).
6. En la página Create policy (Crear política), seleccione Create Your Own Policy (Crear su propia
política).
7. En la página Review policy (Revisar política), facilite la información siguiente:

• Nombre de la política: introduzca un nombre único; por ejemplo,MyDAXUserPolicy.


• Descripción: introduzca una breve descripción de la política.
• Policy Document: copie y pegue el siguiente documento.

{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"dax:*"
],
"Effect": "Allow",
"Resource": [
"*"
]
},
{
"Action": [
"dynamodb:*"
],
"Effect": "Allow",
"Resource": [
"*"
]
}
]
}

Elija Create Policy.


8. Vuelva a la página Permissions (Permisos). En la lista de políticas, elija Refresh (Actualizar).
9. Para restringir la lista de políticas, elija Filter (Filtro), Customer managed (Administrado por el cliente).
Seleccione la política de IAM que creó en el paso anterior (por ejemplo:MyDAXUserPolicy) y luego
elijaSiguiente: Consulte.
10. En la página Review, elija Create user.
11. En la página Complete (Completar), vaya a Secret access key (Clave de acceso secreta) y elija Show
(Mostrar). Cuando termine, copie los valores de Access key ID (ID de clave de acceso) y Secret
access key (Clave de acceso secreta). Necesita ambos identificadores para Paso 3: Configurar una
instancia de Amazon EC2 (p. 751).

Versión de API 2012-08-10


750
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

Paso 3: Configurar una instancia de Amazon EC2


Una vez que la instancia de Amazon EC2 esté disponible, puede iniciar sesión en la misma y prepararla
para utilizarla.
Note
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 laGuía del usuario de Amazon EC2 para instancias de Linux.

Para configurar la instancia EC2

1. Abra la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/.


2. UsarsshPara iniciar sesión en su instancia Amazon EC2, tal y como se muestra en el siguiente
ejemplo.

ssh -i my-keypair.pem ec2-user@public-dns-name

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

El identificador de inicio de sesión es ec2-user. No se requiere contraseña.


3. Después de iniciar sesión en la instancia EC2, configure suAWSCredenciales como se muestra a
continuación. Escriba suAWSAcceda a la clave de acceso y la clave secreta (Paso 2: Crear un usuario
y una política de IAM (p. 749)Establezca el nombre de región predeterminada en su región actual.
(En el siguiente ejemplo, el nombre de región predeterminada es us-west-2).

aws configure

AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE


AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-west-2
Default output format [None]:

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

Paso 4: Ejecución de un ejemplo de aplicación


Para ayudarle a probar la funcionalidad de Amazon DynamoDB Accelerator (DAX), puede ejecutar una de
las aplicaciones de ejemplo disponibles en la instancia de Amazon EC2.

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)

DAX SDK for Go


Siga este procedimiento para ejecutar la aplicación de ejemplo de Amazon DynamoDB Accelerator (DAX)
SDK for Go en su instancia de Amazon EC2.

Versión de API 2012-08-10


751
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

Para ejecutar el ejemplo de SDK for Go para DAX

1. Configure el SDK for Go on su instancia de Amazon EC2:

a. Instale el lenguaje de programación Go (Golang).

sudo yum install -y golang

b. Compruebe que Golang está instalado y se ejecuta correctamente.

go version

Debería aparecer un mensaje como este.

go version go1.15.5 linux/amd64

Las instrucciones restantes se basan en el soporte del módulo, que se convirtió en el


predeterminado con Go versión 1.13.
2. Instale la aplicación Golang de ejemplo.

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.

go run ~/go/src/github.com/aws-samples/aws-dax-go-sample/try_dax.go -service dynamodb -


command create-table

go run ~/go/src/github.com/aws-samples/aws-dax-go-sample/try_dax.go -service dynamodb -


command put-item

4. Ejecute los siguientes programas de Golang.

go run ~/go/src/github.com/aws-samples/aws-dax-go-sample/try_dax.go -service dynamodb -


command get-item

go run ~/go/src/github.com/aws-samples/aws-dax-go-sample/try_dax.go -service dynamodb -


command query

go run ~/go/src/github.com/aws-samples/aws-dax-go-sample/try_dax.go -service dynamodb -


command scan

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

• Mediante laAWS CLIEscriba el siguiente comando.

aws dax describe-clusters --query "Clusters[*].ClusterDiscoveryEndpoint"

El punto de enlace del clúster se muestra en el resultado, como en el siguiente ejemplo.

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

go run ~/go/src/github.com/aws-samples/aws-dax-go-sample/try_dax.go -service dax -


command get-item -endpoint dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com

go run ~/go/src/github.com/aws-samples/aws-dax-go-sample/try_dax.go -service dax -


command query -endpoint dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com

go run ~/go/src/github.com/aws-samples/aws-dax-go-sample/try_dax.go -service dax -


command scan -endpoint dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com

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.

go run ~/go/src/github.com/aws-samples/aws-dax-go-sample/try_dax.go -service dynamodb -


command delete-table

Java y DAX
Siga este procedimiento para ejecutar el ejemplo de Java para Amazon DynamoDB Accelerator (DAX) en
su instancia Amazon EC2.

Para ejecutar el ejemplo de Java para DAX

1. Instale el kit de desarrollo de Java (JDK).

sudo yum install -y java-devel

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

3. Descargue en la última versión del cliente Java de DAX (.jarfile).


Versión de API 2012-08-10
753
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

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/*

5. Descargue el código fuente del programa de ejemplo (archivo .zip).

wget http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/TryDax.zip

Cuando haya terminado la descarga, extraiga los archivos de código fuente.

unzip TryDax.zip

6. Navegue hasta el directorio de código Java y compile el código de la siguiente manera.

cd TryDax/java/
javac TryDax*.java

7. Ejecute el programa.

java TryDax

Debería ver un resultado similar a este.

Creating a DynamoDB client

Attempting to create table; please wait...


Successfully created table. Table status: ACTIVE
Writing data to the table...
Writing 10 items for partition key: 1
Writing 10 items for partition key: 2
Writing 10 items for partition key: 3
Writing 10 items for partition key: 4
Writing 10 items for partition key: 5
Writing 10 items for partition key: 6
Writing 10 items for partition key: 7
Writing 10 items for partition key: 8
Writing 10 items for partition key: 9
Writing 10 items for partition key: 10

Running GetItem, Scan, and Query tests...


First iteration of each test will result in cache misses
Next iterations are cache hits

GetItem test - partition key 1 and sort keys 1-10


Total time: 136.681 ms - Avg time: 13.668 ms
Total time: 122.632 ms - Avg time: 12.263 ms
Versión de API 2012-08-10
754
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

Total time: 167.762 ms - Avg time: 16.776 ms


Total time: 108.130 ms - Avg time: 10.813 ms
Total time: 137.890 ms - Avg time: 13.789 ms
Query test - partition key 5 and sort keys between 2 and 9
Total time: 13.560 ms - Avg time: 2.712 ms
Total time: 11.339 ms - Avg time: 2.268 ms
Total time: 7.809 ms - Avg time: 1.562 ms
Total time: 10.736 ms - Avg time: 2.147 ms
Total time: 12.122 ms - Avg time: 2.424 ms
Scan test - all items in the table
Total time: 58.952 ms - Avg time: 11.790 ms
Total time: 25.507 ms - Avg time: 5.101 ms
Total time: 37.660 ms - Avg time: 7.532 ms
Total time: 26.781 ms - Avg time: 5.356 ms
Total time: 46.076 ms - Avg time: 9.215 ms

Attempting to delete table; please wait...


Successfully deleted table.

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

• Mediante laAWS CLIEscriba el siguiente comando.

aws dax describe-clusters --query "Clusters[*].ClusterDiscoveryEndpoint"

El punto de enlace del clúster se muestra en el resultado, como en el siguiente ejemplo.

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

java TryDax dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com

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:

• TryDax.java (p. 756)


• TryDaxHelper.java (p. 757)
Versión de API 2012-08-10
755
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

• TryDaxTests.java (p. 760)

Uso del cliente como dependencia de Apache Maven

Siga estos pasos para utilizar el cliente para el SDK de DAX para Java en su aplicación como una
dependencia.

Para usar el cliente como una dependencia de Maven

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.

Puede modificar el programa de varias maneras:

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

Versión de API 2012-08-10


756
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicació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.
*/
import com.amazonaws.services.dynamodbv2.document.DynamoDB;

public class TryDax {

public static void main(String[] args) throws Exception {

TryDaxHelper helper = new TryDaxHelper();


TryDaxTests tests = new TryDaxTests();

DynamoDB ddbClient = helper.getDynamoDBClient();


DynamoDB daxClient = null;
if (args.length >= 1) {
daxClient = helper.getDaxClient(args[0]);
}

String tableName = "TryDaxTable";

System.out.println("Creating table...");
helper.createTable(tableName, ddbClient);
System.out.println("Populating table...");
helper.writeData(tableName, ddbClient, 10, 10);

DynamoDB testClient = null;


if (daxClient != null) {
testClient = daxClient;
} else {
testClient = ddbClient;
}

System.out.println("Running GetItem, Scan, and Query tests...");


System.out.println("First iteration of each test will result in cache misses");
System.out.println("Next iterations are cache hits\n");

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

El archivo TryDaxHelper.java contiene métodos de utilidad.

Versión de API 2012-08-10


757
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

LagetDynamoDBClientygetDaxClientLos métodos de proporcionan clientes de Amazon DynamoDB y


DynamoDB Accelerator (DAX). Para operaciones de plano de control (CreateTable,DeleteTable) y las
operaciones de escritura, el programa utiliza el cliente DynamoDB. Si especifica el punto de enlace de un
clúster de DAX, el programa principal crea un cliente de DAX para llevar a cabo las operaciones de lectura
(GetItem,Query,Scan).

El otroTryDaxHelperMétodos (createTable,writeData,deleteTable) se utilizan para configurar y


eliminar la tabla DynamoDB y sus datos.

Puede modificar el programa de varias maneras:

• Utilizar unos ajustes de desempeño provisionado diferentes para la tabla.


• Modificar el tamaño de cada elemento escrito (consulte la variable stringSize del método
writeData).
• Modificar el número de pruebas de GetItem, Query y Scan y 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) .
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;

public class TryDaxHelper {

private static final String region = EC2MetadataUtils.getEC2InstanceRegion();

DynamoDB getDynamoDBClient() {

Versión de API 2012-08-10


758
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

System.out.println("Creating a DynamoDB client");


AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()
.withRegion(region)
.build();
return new DynamoDB(client);
}

DynamoDB getDaxClient(String daxEndpoint) {


System.out.println("Creating a DAX client with cluster endpoint " + daxEndpoint);
AmazonDaxClientBuilder daxClientBuilder = AmazonDaxClientBuilder.standard();
daxClientBuilder.withRegion(region).withEndpointConfiguration(daxEndpoint);
AmazonDynamoDB client = daxClientBuilder.build();
return new DynamoDB(client);
}

void createTable(String tableName, DynamoDB client) {


Table table = client.getTable(tableName);
try {
System.out.println("Attempting to create table; please wait...");

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

void writeData(String tableName, DynamoDB client, int pkmax, int skmax) {


Table table = client.getTable(tableName);
System.out.println("Writing data to the table...");

int stringSize = 1000;


StringBuilder sb = new StringBuilder(stringSize);
for (int i = 0; i < stringSize; i++) {
sb.append('X');
}
String someData = sb.toString();

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

void deleteTable(String tableName, DynamoDB client) {

Versión de API 2012-08-10


759
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

Table table = client.getTable(tableName);


try {
System.out.println("\nAttempting to delete table; please wait...");
table.delete();
table.waitForDelete();
System.out.println("Successfully deleted table.");

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

Puede modificar el programa de varias maneras:

• Modificar el método queryTest de modo que use otra expresión KeyConditionExpression.


• Agregar un filtro ScanFilter al método scanTest para que solamente se devuelvan algunos de los
elementos.

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;

Versión de API 2012-08-10


760
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

public class TryDaxTests {

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

for (int i = 0; i < iterations; i++) {


startTime = System.nanoTime();
try {
for (Integer ipk = 1; ipk <= pk; ipk++) {
for (Integer isk = 1; isk <= sk; isk++) {
table.getItem("pk", ipk, "sk", isk);
}
}
} catch (Exception e) {
System.err.println("Unable to get item:");
e.printStackTrace();
}
endTime = System.nanoTime();
printTime(startTime, endTime, pk * sk);
}
}

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

HashMap<String, Object> valueMap = new HashMap<String, Object>();


valueMap.put(":pkval", pk);
valueMap.put(":skval1", sk1);
valueMap.put(":skval2", sk2);

QuerySpec spec = new QuerySpec()


.withKeyConditionExpression("pk = :pkval and sk between :skval1
and :skval2")
.withValueMap(valueMap);

for (int i = 0; i < iterations; i++) {


startTime = System.nanoTime();
ItemCollection<QueryOutcome> items = table.query(spec);

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

void scanTest(String tableName, DynamoDB client, int iterations) {


long startTime, endTime;
System.out.println("Scan test - all items in the table");
Table table = client.getTable(tableName);

Versión de API 2012-08-10


761
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

for (int i = 0; i < iterations; i++) {


startTime = System.nanoTime();
ItemCollection<ScanOutcome> items = table.scan();
try {

Iterator<Item> iter = items.iterator();


while (iter.hasNext()) {
iter.next();
}
} catch (Exception e) {
System.err.println("Unable to scan table:");
e.printStackTrace();
}
endTime = System.nanoTime();
printTime(startTime, endTime, iterations);
}
}

public void printTime(long startTime, long endTime, int iterations) {


System.out.format("\tTotal time: %.3f ms - ", (endTime - startTime) / (1000000.0));
System.out.format("Avg time: %.3f ms\n", (endTime - startTime) / (iterations *
1000000.0));
}
}

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

Para ejecutar el ejemplo de .NET para DAX

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

Esto debería imprimir el número de versión del SDK principal de .NET.


Note

En lugar del número de versión, podría recibir el error siguiente:

Versión de API 2012-08-10


762
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

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.

sudo yum install -y libunwind

Después de esto, debería poder ejecutar el comando dotnet --version sin errores.
4. Creación de un nuevo proyecto de .NET.

dotnet new console -o myApp

Esto requiere algunos minutos para llevar a cabo una configuración solo una vez. Cuando se
complete, ejecute el proyecto de ejemplo.

dotnet run --project myApp

Debería recibir el siguiente mensaje: Hello World!


5. El archivo myApp/myApp.csproj contiene metadatos acerca de su proyecto. Para utilizar el cliente
DAX de en su aplicación, modifique el archivo para que tenga un aspecto similar a lo siguiente.

<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>netcoreapp2.0</TargetFramework>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="AWSSDK.DAX.Client" Version="*" />
</ItemGroup>
</Project>

6. Descargue el código fuente del programa de ejemplo (archivo .zip).

wget http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/TryDax.zip

Cuando haya terminado la descarga, extraiga los archivos de código fuente.

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

8. A continuación, ejecute algunos programas para realizarGetItem,Query, yScanOperaciones de


su clúster de 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
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

• Mediante laAWS CLIEscriba el siguiente comando.

aws dax describe-clusters --query "Clusters[*].ClusterDiscoveryEndpoint"

El punto de enlace del clúster se muestra en el resultado, como en el siguiente ejemplo.

{
"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 (p. 764)


• 02-Write-Data.cs (p. 765)
• 03-GetItem-Test.cs (p. 766)
• 04-Query-Test.cs (p. 768)
• 05-Scan-Test.cs (p. 769)
• 06-DeleteTable.cs (p. 770)

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.

Versión de API 2012-08-10


764
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

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

AmazonDynamoDBClient client = new AmazonDynamoDBClient();

var tableName = "TryDaxTable";

var request = new CreateTableRequest()


{
TableName = tableName,
KeySchema = new List<KeySchemaElement>()
{
new KeySchemaElement{ AttributeName = "pk",KeyType = "HASH"},
new KeySchemaElement{ AttributeName = "sk",KeyType = "RANGE"}
},
AttributeDefinitions = new List<AttributeDefinition>() {
new AttributeDefinition{ AttributeName = "pk",AttributeType = "N"},
new AttributeDefinition{ AttributeName = "sk",AttributeType = "N"}
},
ProvisionedThroughput = new ProvisionedThroughput()
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 10
}
};

var response = client.CreateTableAsync(request).Result;

Console.WriteLine("Hit <enter> to continue...");


Console.ReadLine();
}
}
}

02-Write-Data.cs

El programa 02-Write-Data.cs 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").

Versión de API 2012-08-10


765
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

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

AmazonDynamoDBClient client = new AmazonDynamoDBClient();

var tableName = "TryDaxTable";

string someData = new String('X', 1000);


var pkmax = 10;
var skmax = 10;

for (var ipk = 1; ipk <= pkmax; ipk++)


{
Console.WriteLine("Writing " + skmax + " items for partition key: " + ipk);
for (var isk = 1; isk <= skmax; isk++)
{
var request = new PutItemRequest()
{
TableName = tableName,
Item = new Dictionary<string, AttributeValue>()
{
{ "pk", new AttributeValue{N = ipk.ToString() } },
{ "sk", new AttributeValue{N = isk.ToString() } },
{ "someData", new AttributeValue{S = someData } }
}
};

var response = client.PutItemAsync(request).Result;

}
}

Console.WriteLine("Hit <enter> to continue...");


Console.ReadLine();
}
}
}

03-GetItem-Test.cs

El programa 03-GetItem-Test.cs escribe realiza operaciones GetItem en TryDaxTable.

/**
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.

Versión de API 2012-08-10


766
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

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

String hostName = args[0].Split(':')[0];


int port = Int32.Parse(args[0].Split(':')[1]);
Console.WriteLine("Using DAX client - hostname=" + hostName + ", port=" +
port);

var clientConfig = new DaxClientConfig(hostName, port)


{
AwsCredentials = FallbackCredentialsFactory.GetCredentials()

};
var client = new ClusterDaxClient(clientConfig);

var tableName = "TryDaxTable";

var pk = 1;
var sk = 10;
var iterations = 5;

var startTime = DateTime.Now;

for (var i = 0; i < iterations; i++)


{

for (var ipk = 1; ipk <= pk; ipk++)


{
for (var isk = 1; isk <= sk; isk++)
{
var request = new GetItemRequest()
{
TableName = tableName,
Key = new Dictionary<string, AttributeValue>() {
{"pk", new AttributeValue {N = ipk.ToString()} },
{"sk", new AttributeValue {N = isk.ToString() } }
}
};
var response = client.GetItemAsync(request).Result;
Console.WriteLine("GetItem succeeded for pk: " + ipk + ", sk: " +
isk);
}
}

Versión de API 2012-08-10


767
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

var endTime = DateTime.Now;


TimeSpan timeSpan = endTime - startTime;
Console.WriteLine("Total time: " + (int)timeSpan.TotalMilliseconds + "
milliseconds");

Console.WriteLine("Hit <enter> to continue...");


Console.ReadLine();
}
}
}

04-Query-Test.cs

El programa 04-Query-Test.cs 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.
*/
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)
{

String hostName = args[0].Split(':')[0];


int port = Int32.Parse(args[0].Split(':')[1]);
Console.WriteLine("Using DAX client - hostname=" + hostName + ", port=" +
port);

var clientConfig = new DaxClientConfig(hostName, port)


{
AwsCredentials = FallbackCredentialsFactory.GetCredentials()

};
var client = new ClusterDaxClient(clientConfig);

var tableName = "TryDaxTable";

Versión de API 2012-08-10


768
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

var pk = 5;
var sk1 = 2;
var sk2 = 9;
var iterations = 5;

var startTime = DateTime.Now;

for (var i = 0; i < iterations; i++)


{
var request = new QueryRequest()
{
TableName = tableName,
KeyConditionExpression = "pk = :pkval and sk between :skval1
and :skval2",
ExpressionAttributeValues = new Dictionary<string, AttributeValue>() {
{":pkval", new AttributeValue {N = pk.ToString()} },
{":skval1", new AttributeValue {N = sk1.ToString()} },
{":skval2", new AttributeValue {N = sk2.ToString()} }
}
};
var response = client.QueryAsync(request).Result;
Console.WriteLine(i + ": Query succeeded");

var endTime = DateTime.Now;


TimeSpan timeSpan = endTime - startTime;
Console.WriteLine("Total time: " + (int)timeSpan.TotalMilliseconds + "
milliseconds");

Console.WriteLine("Hit <enter> to continue...");


Console.ReadLine();
}
}
}

05-Scan-Test.cs

El programa 05-Scan-Test.cs 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.
*/
using Amazon.Runtime;
using Amazon.DAX;
using Amazon.DynamoDBv2.Model;
using System.Collections.Generic;
using System;
using Amazon.DynamoDBv2;
using Amazon;

namespace ClientTest

Versión de API 2012-08-10


769
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

{
class Program
{
static void Main(string[] args)
{

String hostName = args[0].Split(':')[0];


int port = Int32.Parse(args[0].Split(':')[1]);
Console.WriteLine("Using DAX client - hostname=" + hostName + ", port=" +
port);

var clientConfig = new DaxClientConfig(hostName, port)


{
AwsCredentials = FallbackCredentialsFactory.GetCredentials(

};
var client = new ClusterDaxClient(clientConfig);

var tableName = "TryDaxTable";

var iterations = 5;

var startTime = DateTime.Now;

for (var i = 0; i < iterations; i++)


{
var request = new ScanRequest()
{
TableName = tableName
};
var response = client.ScanAsync(request).Result;
Console.WriteLine(i + ": Scan succeeded");
}

var endTime = DateTime.Now;


TimeSpan timeSpan = endTime - startTime;
Console.WriteLine("Total time: " + (int)timeSpan.TotalMilliseconds + "
milliseconds");

Console.WriteLine("Hit <enter> to continue...");


Console.ReadLine();
}
}
}

06-DeleteTable.cs

El programa 06-DeleteTable.cs elimina TryDaxTable. Ejecute este programa después de haber


terminado las pruebas.

/**
* 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

Versión de API 2012-08-10


770
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

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

AmazonDynamoDBClient client = new AmazonDynamoDBClient();

var tableName = "TryDaxTable";

var request = new DeleteTableRequest()


{
TableName = tableName
};

var response = client.DeleteTableAsync(request).Result;

Console.WriteLine("Hit <enter> to continue...");


Console.ReadLine();
}
}

Node.js y DAX
Siga estos pasos para ejecutar la aplicación de ejemplo de Node.js en su instancia de Amazon EC2.

Para ejecutar el ejemplo de Node.js para DAX

1. Configure Node.js en la instancia Amazon EC2, de la siguiente manera:

a. Instale el administrador de la versión de nodo (nvm).

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash

b. Use nvm para instalar Node.js.

nvm install 12.16.3

c. Compruebe que Node.js está instalado y se ejecuta correctamente.

node -e "console.log('Running Node.js ' + process.version)"

Esto debería mostrar el mensaje siguiente.

Running Node.js v12.16.3


2. Instale el cliente DAX Node.js de utilizando el administrador de paquetes de nodos (npm).

npm install amazon-dax-client

Versión de API 2012-08-10


771
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

3. Descargue el código fuente del programa de ejemplo (archivo .zip).

wget http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/TryDax.zip

Cuando haya terminado la descarga, extraiga los archivos de código fuente.

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

5. Ejecute los siguientes programas de Node.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

• Mediante laAWS CLI: Escriba el siguiente comando.

aws dax describe-clusters --query "Clusters[*].ClusterDiscoveryEndpoint"

El punto de enlace del clúster se muestra en el resultado, como en el siguiente ejemplo.

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

node 03-getitem-test.js dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com


node 04-query-test.js dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
node 05-scan-test.js dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com

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 (p. 773)


• 02-write-data.js (p. 774)
• 03-getitem-test.js (p. 775)
• 04-query-test.js (p. 776)
• 05-scan-test.js (p. 777)
• 06-delete-table.js (p. 778)

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

var region = "us-west-2";

AWS.config.update({
region: region
});

var dynamodb = new AWS.DynamoDB() //low-level client

var tableName = "TryDaxTable";

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
}
};

Versión de API 2012-08-10


773
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

dynamodb.createTable(params, function(err, data) {


if (err) {
console.error("Unable to create table. Error JSON:", JSON.stringify(err, null, 2));
} else {
console.log("Created table. Table description JSON:", JSON.stringify(data, null,
2));
}
});

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

var region = "us-west-2";

AWS.config.update({
region: region
});

var ddbClient = new AWS.DynamoDB.DocumentClient()

var tableName = "TryDaxTable";

var someData = "X".repeat(1000);


var pkmax = 10;
var skmax = 10;

for (var ipk = 1; ipk <= pkmax; ipk++) {

for (var isk = 1; isk <= skmax; isk++) {


var params = {
TableName: tableName,
Item: {
"pk": ipk,
"sk": isk,
"someData": someData
}
};

//
//put item

ddbClient.put(params, function(err, data) {


if (err) {
console.error("Unable to write data: ", JSON.stringify(err, null, 2));

Versión de API 2012-08-10


774
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

} 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");

var region = "us-west-2";

AWS.config.update({
region: region
});

var ddbClient = new AWS.DynamoDB.DocumentClient()


var daxClient = null;

if (process.argv.length > 2) {
var dax = new AmazonDaxClient({endpoints: [process.argv[2]], region: region})
daxClient = new AWS.DynamoDB.DocumentClient({service: dax });
}

var client = daxClient != null ? daxClient : ddbClient;


var tableName = "TryDaxTable";

var pk = 1;
var sk = 10;
var iterations = 5;

for (var i = 0; i < iterations; i++) {

var startTime = new Date().getTime();

for (var ipk = 1; ipk <= pk; ipk++) {


for (var isk = 1; isk <= sk; isk++) {

var params = {
TableName: tableName,
Key:{
"pk": ipk,
"sk": isk
}

Versión de API 2012-08-10


775
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

};

client.get(params, function(err, data) {


if (err) {
console.error("Unable to read item. Error JSON:", JSON.stringify(err,
null, 2));
} else {
// GetItem succeeded
}
});
}
}

var endTime = new Date().getTime();


console.log("\tTotal time: ", (endTime - startTime) , "ms - Avg time: ", (endTime -
startTime) / iterations, "ms");

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

var region = "us-west-2";

AWS.config.update({
region: region
});

var ddbClient = new AWS.DynamoDB.DocumentClient()


var daxClient = null;

if (process.argv.length > 2) {
var dax = new AmazonDaxClient({endpoints: [process.argv[2]], region: region})
daxClient = new AWS.DynamoDB.DocumentClient({service: dax });
}

var client = daxClient != null ? daxClient : ddbClient;


var tableName = "TryDaxTable";

var pk = 5;
var sk1 = 2;
var sk2 = 9;
var iterations = 5;

var params = {
TableName: tableName,

Versión de API 2012-08-10


776
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

KeyConditionExpression: "pk = :pkval and sk between :skval1 and :skval2",


ExpressionAttributeValues: {
":pkval":pk,
":skval1":sk1,
":skval2":sk2
}
};

for (var i = 0; i < iterations; i++) {


var startTime = new Date().getTime();

client.query(params, function(err, data) {


if (err) {
console.error("Unable to read item. Error JSON:", JSON.stringify(err, null,
2));
} else {
// Query succeeded
}
});

var endTime = new Date().getTime();


console.log("\tTotal time: ", (endTime - startTime) , "ms - Avg time: ", (endTime -
startTime) / iterations, "ms");

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

var region = "us-west-2";

AWS.config.update({
region: region
});

var ddbClient = new AWS.DynamoDB.DocumentClient()


var daxClient = null;

if (process.argv.length > 2) {
var dax = new AmazonDaxClient({endpoints: [process.argv[2]], region: region})
daxClient = new AWS.DynamoDB.DocumentClient({service: dax });
}

var client = daxClient != null ? daxClient : ddbClient;


var tableName = "TryDaxTable";

Versión de API 2012-08-10


777
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

var iterations = 5;

var params = {
TableName: tableName
};
var startTime = new Date().getTime();
for (var i = 0; i < iterations; i++) {

client.scan(params, function(err, data) {


if (err) {
console.error("Unable to read item. Error JSON:", JSON.stringify(err, null,
2));
} else {
// Scan succeeded
}
});

var endTime = new Date().getTime();


console.log("\tTotal time: ", (endTime - startTime) , "ms - Avg time: ", (endTime -
startTime) / iterations, "ms");

06-delete-table.js

El programa 06-delete-table.js elimina TryDaxTable. Ejecute este programa después de haber


terminado las pruebas.

/**
* 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");

var region = "us-west-2";

AWS.config.update({
region: region
});

var dynamodb = new AWS.DynamoDB(); //low-level client

var tableName = "TryDaxTable";

var params = {
TableName : tableName
};

dynamodb.deleteTable(params, function(err, data) {


if (err) {

Versión de API 2012-08-10


778
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

console.error("Unable to delete table. Error JSON:", JSON.stringify(err, null, 2));


} else {
console.log("Deleted table. Table description JSON:", JSON.stringify(data, null,
2));
}
});

Python y DAX
Siga este procedimiento para ejecutar la aplicación de ejemplo de Python en su instancia de Amazon EC2.

Para ejecutar el ejemplo de Python para DAX

1. Instale el cliente DAX Python utilizando elpipUtilidad.

pip install amazon-dax-client

2. Descargue el código fuente del programa de ejemplo (archivo .zip).

wget http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/TryDax.zip

Cuando haya terminado la descarga, extraiga los archivos de código fuente.

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

4. Ejecute los siguientes programas de Python.

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

• Mediante laAWS CLIEscriba el siguiente comando.

aws dax describe-clusters --query "Clusters[*].ClusterDiscoveryEndpoint"

El punto de enlace del clúster se muestra en la salida, como en este ejemplo.


Versión de API 2012-08-10
779
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

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

python 03-getitem-test.py dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com


python 04-query-test.py dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
python 05-scan-test.py dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com

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 (p. 780)


• 02-write-data.py (p. 781)
• 03-getitem-test.py (p. 781)
• 04-query-test.py (p. 782)
• 05-scan-test.py (p. 783)
• 06-delete-table.py (p. 784)

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.

:param dyn_resource: Either a Boto3 or DAX resource.


:return: The newly created table.
"""
if dyn_resource is None:
dyn_resource = boto3.resource('dynamodb')

table_name = 'TryDaxTable'
params = {
'TableName': table_name,
'KeySchema': [
{'AttributeName': 'partition_key', 'KeyType': 'HASH'},
{'AttributeName': 'sort_key', 'KeyType': 'RANGE'}
],
'AttributeDefinitions': [

Versión de API 2012-08-10


780
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

{'AttributeName': 'partition_key', 'AttributeType': 'N'},


{'AttributeName': 'sort_key', 'AttributeType': 'N'}
],
'ProvisionedThroughput': {
'ReadCapacityUnits': 10,
'WriteCapacityUnits': 10
}
}
table = dyn_resource.create_table(**params)
print(f"Creating {table_name}...")
table.wait_until_exists()
return table

if __name__ == '__main__':
dax_table = create_dax_table()
print(f"Created table.")

02-write-data.py

El programa 02-write-data.py escribe datos de prueba en TryDaxTable.

import boto3

def write_data_to_dax_table(key_count, item_size, dyn_resource=None):


"""
Writes test data to the demonstration table.

: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

for partition_key in range(1, key_count + 1):


for sort_key in range(1, key_count + 1):
table.put_item(Item={
'partition_key': partition_key,
'sort_key': sort_key,
'some_data': some_data
})
print(f"Put item ({partition_key}, {sort_key}) succeeded.")

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

El programa 03-getitem-test.py escribe realiza operaciones GetItem en TryDaxTable.

import argparse
import sys

Versión de API 2012-08-10


781
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

import time
import amazondax
import boto3

def get_item_test(key_count, iterations, dyn_resource=None):


"""
Gets items from the table a specified number of times. The time before the
first iteration and the time after the last iteration are both captured
and reported.

: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

Versión de API 2012-08-10


782
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

import sys
import amazondax
import boto3
from boto3.dynamodb.conditions import Key

def query_test(partition_key, sort_keys, iterations, dyn_resource=None):


"""
Queries the table a specified number of times. The time before the
first iteration and the time after the last iteration are both captured
and reported.

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

print(f"Total time: {test_end - test_start:.4f} sec. Average time: "


f"{(test_end - test_start)/test_iterations}.")

05-scan-test.py

El programa 05-scan-test.py escribe realiza operaciones Scan en TryDaxTable.

Versión de API 2012-08-10


783
Amazon DynamoDB Guía para desarrolladores
Tutorial: Ejecución de un ejemplo de aplicación

import argparse
import time
import sys
import amazondax
import boto3

def scan_test(iterations, dyn_resource=None):


"""
Scans the table a specified number of times. The time before the
first iteration and the time after the last iteration are both captured
and reported.

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

:param dyn_resource: Either a Boto3 or DAX resource.


"""

Versión de API 2012-08-10


784
Amazon DynamoDB Guía para desarrolladores
Modificación de una aplicación existente para que use DAX

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

Modificación de una aplicación existente para que use


DAX
Si ya dispone de una aplicación Java que utiliza Amazon DynamoDB, deberá modificarla para que
pueda obtener acceso al clúster de DynamoDB Accelerator (DAX). No tiene que volver a escribir toda la
aplicación porque el cliente Java de DAX es similar al cliente de bajo nivel de DynamoDB que se incluye en
elAWS SDK for Java.

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;

public class GetMusicItem {

public static void main(String[] args) throws Exception {

// Create a DynamoDB client


AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();

HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();


key.put("Artist", new AttributeValue().withS("No One You Know"));
key.put("SongTitle", new AttributeValue().withS("Scared of My Shadow"));

GetItemRequest request = new GetItemRequest()


.withTableName("Music").withKey(key);

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

Para modificar el programa, se sustituye el cliente de DynamoDB por un cliente de DAX.

Versión de API 2012-08-10


785
Amazon DynamoDB Guía para desarrolladores
Modificación de una aplicación existente para que use DAX

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;

public class GetMusicItem {

public static void main(String[] args) throws Exception {

//Create a DAX client

AmazonDaxClientBuilder daxClientBuilder = AmazonDaxClientBuilder.standard();


daxClientBuilder.withRegion("us-
east-1").withEndpointConfiguration("mydaxcluster.2cmrwl.clustercfg.dax.use1.cache.amazonaws.com:8111");
AmazonDynamoDB client = daxClientBuilder.build();

/*
** ...
** Remaining code omitted (it is identical)
** ...
*/

}
}

Uso de la API de documentos de DynamoDB


LaAWS SDK for JavaProporciona una interfaz de documentos para DynamoDB. La API de documentos
actúa como encapsulador del cliente de bajo nivel de DynamoDB. Para obtener más información, consulte
Interfaces de documentos.

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;

public class GetMusicItemWithDocumentApi {

public static void main(String[] args) throws Exception {

//Create a DAX client

AmazonDaxClientBuilder daxClientBuilder = AmazonDaxClientBuilder.standard();


daxClientBuilder.withRegion("us-
east-1").withEndpointConfiguration("mydaxcluster.2cmrwl.clustercfg.dax.use1.cache.amazonaws.com:8111");
AmazonDynamoDB client = daxClientBuilder.build();

// Document client wrapper


DynamoDB docClient = new DynamoDB(client);

Table table = docClient.getTable("Music");

try {
System.out.println("Attempting to read the item...");
GetItemOutcome outcome = table.tgetItemOutcome(

Versión de API 2012-08-10


786
Amazon DynamoDB Guía para desarrolladores
Modificación de una aplicación existente para que use DAX

"Artist", "No One You Know",


"SongTitle", "Scared of My Shadow");
System.out.println(outcome.getItem());
System.out.println("GetItem succeeded: " + outcome);
} catch (Exception e) {
System.err.println("Unable to read item");
System.err.println(e.getMessage());
}

}
}

Cliente asincrónico de DAX


El AmazonDaxClient es sincrónico. Para una operación de API DAX de larga duración, como unScanDe
una tabla grande, esto puede bloquear la ejecución del programa hasta que se haya completado la
operación. Si el programa necesita realizar otros trabajos mientras que la operación del API de DAX está
en curso, puede utilizarClusterDaxAsyncClientEn su lugar,

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;

public class DaxAsyncClientDemo {


public static void main(String[] args) throws Exception {

ClientConfig daxConfig = new ClientConfig().withCredentialsProvider(new


ProfileCredentialsProvider())
.withEndpoints("mydaxcluster.2cmrwl.clustercfg.dax.use1.cache.amazonaws.com:8111");

AmazonDynamoDBAsync client = new ClusterDaxAsyncClient(daxConfig);

HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();


key.put("Artist", new AttributeValue().withS("No One You Know"));
key.put("SongTitle", new AttributeValue().withS("Scared of My Shadow"));

GetItemRequest request = new GetItemRequest()

Versión de API 2012-08-10


787
Amazon DynamoDB Guía para desarrolladores
Consulta de índices secundarios globales

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

} catch (ExecutionException ee) {


// Futures always wrap errors as an ExecutionException.
// The *real* exception is stored as the cause of the
// ExecutionException
Throwable exception = ee.getCause();
System.out.println("Error getting item: " + exception.getMessage());
}

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

}
}

Consulta de índices secundarios globales


Puede utilizar Amazon DynamoDB Accelerator (DAX) para consultarÍndices secundarios globales deUso
de DynamoDBInterfaces de programación.

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;

Versión de API 2012-08-10


788
Amazon DynamoDB Guía para desarrolladores
Consulta de índices secundarios globales

public class DaxClient {

private static final String region = EC2MetadataUtils.getEC2InstanceRegion();

DynamoDB getDaxDocClient(String daxEndpoint) {


System.out.println("Creating a DAX client with cluster endpoint " + daxEndpoint);
AmazonDaxClientBuilder daxClientBuilder = AmazonDaxClientBuilder.standard();

daxClientBuilder.withRegion(region).withEndpointConfiguration(daxEndpoint);
AmazonDynamoDB client = daxClientBuilder.build();

return new DynamoDB(client);


}

DynamoDBMapper getDaxMapperClient(String daxEndpoint) {


System.out.println("Creating a DAX client with cluster endpoint " + daxEndpoint);
AmazonDaxClientBuilder daxClientBuilder = AmazonDaxClientBuilder.standard();

daxClientBuilder.withRegion(region).withEndpointConfiguration(daxEndpoint);
AmazonDynamoDB client = daxClientBuilder.build();

return new DynamoDBMapper(client);


}
}

Puede consultar un índice secundario global en de las siguientes maneras:

• Use el método queryIndex de la clase QueryIndexDax definida en el ejemplo siguiente.


QueryIndexDax toma como parámetro el objeto de cliente devuelto por el método getDaxDocClient
para la clase DaxClient.
• Si usa la interfaz de persistencia de objetos, utilice el método queryIndexMapper de la clase
QueryIndexDax definida en el ejemplo siguiente. queryIndexMapper toma como parámetro el objeto
de cliente devuelto por el método getDaxMapperClient definido para la clase DaxClient.

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;

public class QueryIndexDax {

//This is used to query Index using the low-level interface.


public static void queryIndex(DynamoDB client, String tableName, String indexName) {
Table table = client.getTable(tableName);

System.out.println("\n***********************************************************\n");
System.out.print("Querying index " + indexName + "...");

Index index = table.getIndex(indexName);

ItemCollection<QueryOutcome> items = null;

Versión de API 2012-08-10


789
Amazon DynamoDB Guía para desarrolladores
Consulta de índices secundarios globales

QuerySpec querySpec = new QuerySpec();

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;
}

Iterator<Item> iterator = items.iterator();

System.out.println("Query: printing results...");

while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}

//This is used to query Index using the high-level mapper interface.


public static void queryIndexMapper(DynamoDBMapper mapper, String tableName, String
indexName) {
HashMap<String, AttributeValue> eav = new HashMap<String, AttributeValue>();
eav.put(":v_date", new AttributeValue().withS("2013-11-01"));
eav.put(":v_issue", new AttributeValue().withS("A-"));
DynamoDBQueryExpression<CreateDate> queryExpression = new
DynamoDBQueryExpression<CreateDate>()
.withIndexName("CreateDateIndex").withConsistentRead(false)
.withKeyConditionExpression("CreateDate = :v_date and begins_with(IssueId, :v_issue)")
.withExpressionAttributeValues(eav);

List<CreateDate> items = mapper.query(CreateDate.class, queryExpression);


Iterator<CreateDate> iterator = items.iterator();

System.out.println("Query: printing results...");

while (iterator.hasNext()) {
CreateDate iterObj = iterator.next();
System.out.println(iterObj.getCreateDate());
System.out.println(iterObj.getIssueId());
}
}
}

La definición de clase siguiente representa la tabla Issues y se usa en el método queryIndexMapper.

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;

@DynamoDBIndexHashKey(globalSecondaryIndexName = "CreateDateIndex", attributeName =


"CreateDate")
public String getCreateDate() {

Versión de API 2012-08-10


790
Amazon DynamoDB Guía para desarrolladores
Administración de clústeres de DAX

return createDate;
}

public void setCreateDate(String createDate) {


this.createDate = createDate;
}

@DynamoDBIndexRangeKey(globalSecondaryIndexName = "CreateDateIndex", attributeName =


"IssueId")
public String getIssueId() {
return issueId;
}

public void setIssueId(String issueId) {


this.issueId = issueId;
}
}

Administración de clústeres de DAX


En esta sección se abordan algunas de las tareas de administración comunes de los clústeres de Amazon
DynamoDB (DAX).

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)

Permisos de IAM para administrar clústeres de DAX


Cuando administra un clúster de DAX mediante el comandoAWS Management Consoleo elAWS
Command Line Interface(AWS CLI), recomendamos encarecidamente reducir el alcance de las acciones
que los usuarios pueden llevar a cabo. De esta forma, contribuirá a mitigar los riesgos y a respetar el
principio de seguridad de otorgar privilegios mínimos.

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:

• IAM y creación de clústeres DAX:Creación de Cluster de DAX (p. 732).


• Operaciones del plano de datos de IAM y DAX:Control de acceso DAX (p. 814).

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

Versión de API 2012-08-10


791
Amazon DynamoDB Guía para desarrolladores
Permisos de IAM para administrar clústeres de DAX

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.

A modo de ejemplo, tomemos el documento de política de IAM siguiente.

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

Ahora, supongamos que un usuario emite el siguiente comando de la AWS CLI.

aws dax describe-clusters

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",

Versión de API 2012-08-10


792
Amazon DynamoDB Guía para desarrolladores
Escalado de un clúster de DAX

"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 de un clúster de DAX


Existen dos opciones disponibles para escalar un clúster de DAX. La primera opción es el escalado
horizontal, donde se agregan réplicas de lectura al clúster. La segunda opción es el escalado vertical,
donde se seleccionan distintos tipos de nodos. Para obtener información sobre cómo elegir un tamaño
de clúster y un tipo de nodo adecuados para la aplicación, consulte Guía de tamaño de clúster de
DAX (p. 837).

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.

aws dax increase-replication-factor \


--cluster-name MyNewCluster \
--new-replication-factor 5

aws dax decrease-replication-factor \


--cluster-name MyNewCluster \
--new-replication-factor 3

Versión de API 2012-08-10


793
Amazon DynamoDB Guía para desarrolladores
Personalización de los ajustes de los clústeres

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

Personalización de los ajustes de los clústeres


Al crear un clúster de DAX, se utilizan los siguientes ajustes predeterminados:

• Desalojo automático de la caché habilitado con Tiempo de vida (TTL) de 5 minutos


• Sin preferencias respecto a las zonas de disponibilidad
• Sin preferencias respecto a los tiempos de mantenimiento
• Notificaciones deshabilitadas

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.

Versión de API 2012-08-10


794
Amazon DynamoDB Guía para desarrolladores
Configuración de los ajustes de TTL

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.

Configuración de los ajustes de TTL


DAX mantiene dos cachés para datos que lee de DynamoDB:

• Cache de elementos: para los elementos recuperados usandoGetItemorBatchGetItem.


• Caché de consultas: para conjuntos de resultados recuperados usandoQueryorScan.

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.

1. Cree un nuevo grupo de parámetros.

aws dax create-parameter-group \


--parameter-group-name custom-ttl

2. Establezca el TTL de la caché de elementos en 10 minutos (600 000 milisegundos).

aws dax update-parameter-group \


--parameter-group-name custom-ttl \
--parameter-name-values "ParameterName=record-ttl-millis,ParameterValue=600000"

3. Establezca el TTL de la caché de consultas en 3 minutos (180 000 milisegundos).

aws dax update-parameter-group \


--parameter-group-name custom-ttl \
--parameter-name-values "ParameterName=query-ttl-millis,ParameterValue=180000"

4. Compruebe que los parámetros se han configurado correctamente.

aws dax describe-parameters --parameter-group-name custom-ttl \


--query "Parameters[*].[ParameterName,Description,ParameterValue]"

A partir de ahora, puede lanzar un nuevo clúster de DAX con este grupo de parámetros.

aws dax create-cluster \


--cluster-name MyNewCluster \
--node-type dax.r3.large \
--replication-factor 3 \
--iam-role-arn arn:aws:iam::123456789012:role/DAXServiceRole \
--parameter-group custom-ttl

Versión de API 2012-08-10


795
Amazon DynamoDB Guía para desarrolladores
Compatibilidad con el etiquetado en DAX

Note

No se puede modificar un grupo de parámetros que se encuentre en uso en una instancia de DAX
en ejecución.

Compatibilidad con el etiquetado en DAX


MuchosAWSservicios, incluido DynamoDB, soporteetiquetado: la capacidad de etiquetar recursos con
nombres definidos por el usuario. Puede asignar etiquetas a clústeres DAX, lo que le permite identificar
rápidamente todos losAWSque tengan la misma etiqueta, o para categorizar suAWSpor las etiquetas que
asigne.

Para obtener más información, consulte Agregar etiquetas a los recursos (p. 394) .

Mediante AWS Management Console


Para administrar etiquetas de clústeres de DAX

1. Abra la consola de DynamoDB en https://console.aws.amazon.com/dynamodb/.


2. En el panel de navegación, en DAX, elija Clusters (Clústeres).
3. Elija el clúster con el que desee trabajar.
4. Elija la pestaña Tags. Aquí puede agregar, enumerar, editar o eliminar las etiquetas.

Cuando la configuración sea la que desea, elija Apply Changes (Aplicar cambios).

Mediante AWS CLI


Cuando se utiliza elAWS CLIPara administrar etiquetas de clústeres de DAX, es preciso determinar
previamente el nombre de recurso de Amazon (ARN) del clúster. En el siguiente ejemplo se muestra cómo
determinar el ARN de un clúster denominado MyDAXCluster.

aws dax describe-clusters \


--cluster-name MyDAXCluster \
--query "Clusters[*].ClusterArn"

En el resultado, el ARN tendrá un aspecto similar a este: arn:aws:dax:us-


west-2:123456789012:cache/MyDAXCluster

En el siguiente ejemplo se muestra cómo etiquetar el clúster.

aws dax tag-resource \


--resource-name arn:aws:dax:us-west-2:123456789012:cache/MyDAXCluster \
--tags="Key=ClusterUsage,Value=prod"

Para enumerar todas las etiquetas de un clúster.

aws dax list-tags \


--resource-name arn:aws:dax:us-west-2:123456789012:cache/MyDAXCluster

Para eliminar una etiqueta, hay que especificar su clave.

aws dax untag-resource \


--resource-name arn:aws:dax:us-west-2:123456789012:cache/MyDAXCluster \

Versión de API 2012-08-10


796
Amazon DynamoDB Guía para desarrolladores
Integración de AWS CloudTrail

--tag-keys ClusterUsage

Integración de AWS CloudTrail


DAX está integrado conAWS CloudTrail, que permite auditar las actividades de los clústeres de DAX.
Puede utilizar registros de CloudTrail para ver todos los cambios realizados en el nivel de clúster. También
puede los cambios en los componentes de los clústeres, como los nodos, los grupos de subredes y los
grupos de parámetros. Para obtener más información, consulte Registro de operaciones de DynamoDB
utilizandoAWS CloudTrail (p. 964) .

Supresión de clústeres de DAX


Si ya no usa un clúster de DAX, debe eliminarlo para que no se le cobre por los recursos no utilizados.

Puede eliminar un clúster de DAX mediante la consola o laAWS CLI. A continuación se muestra un
ejemplo.

aws dax delete-cluster --cluster-name mydaxcluster

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:

• ¿Cuáles son los objetivos de la monitorización?


• ¿Qué recursos va a monitorizar?
• ¿Con qué frecuencia va a monitorizar estos recursos?
• ¿Qué herramientas de monitorización va a utilizar?
• ¿Quién se encargará de realizar las tareas de monitorización?
• ¿Quién debería recibir una notificación cuando surjan problemas?

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.

Versión de API 2012-08-10


797
Amazon DynamoDB Guía para desarrolladores
Herramientas de monitorización

• Las tasas de error deben permanecer bajas, como se ve en


laErrorRequestCount,FaultRequestCount, yFailedRequestCount Métricas de
CloudWatch (p. 800).

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)

Herramientas de monitorización automatizadas


Puede utilizar las siguientes herramientas de monitorización automatizada para vigilar DAX e informar
cuando haya algún problema:

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

Versión de API 2012-08-10


798
Amazon DynamoDB Guía para desarrolladores
Monitoreo con CloudWatch

Herramientas de monitorización manual


Otra parte importante del monitoreo de DAX implica la monitorización manual de los elementos que
no cubren las alarmas de CloudWatch. El DAX, CloudWatch,Trusted Advisor, y otros tipos deAWS
Management ConsoleLos paneles de proporcionan una vista rápida del estado de suAWSMedio ambiente
de. Es recomendable que también compruebe los archivos de registro de DAX.

• El panel de DAX muestra lo siguiente:


• Estado de los servicios
• La página principal de CloudWatch muestra lo siguiente:
• Alarmas y estado actual
• Gráficos de alarmas y recursos
• Estado de los servicios

Además, puede utilizar CloudWatch para hacer lo siguiente:


• Crear paneles personalizados para monitorizar los servicios que le importan.
• Realizar un gráfico con los datos de las métricas para resolver problemas y descubrir tendencias.
• Buscar y examinar todas sus métricas de recursos de AWS.
• Crear y editar las alarmas de notificación de problemas.

Monitorización con Amazon CloudWatch


Puede monitorear Amazon DynamoDB Accelerator (DAX) mediante Amazon CloudWatch, que recopila
y procesa los datos sin formato de DAX en métricas legibles casi en tiempo real. Estas estadísticas se
registran durante un periodo de dos semanas. Puede obtener acceso a información histórica y disponer de
una mejor perspectiva sobre el rendimiento de su aplicación web o servicio. De forma predeterminada, los
datos de las métricas de DAX se envían a CloudWatch automáticamente. Para obtener más información,
consulte ¿Qué es Amazon CloudWatch? en la guía del usuario de Amazon Cloudwatch.

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)

¿Cómo utilizo las métricas de DAX?


Las métricas mostradas por DAX proporcionan información que puede analizar de diferentes maneras. En
la siguiente lista se indican algunos usos frecuentes de las métricas. Se trata de sugerencias que puede
usar como punto de partida y no de una lista completa.

¿Cómo...? Métricas relevantes

Determinar si se ha producido Monitorice FaultRequestCount para determinar si alguna solicitud


algún error del sistema ha dado lugar a un código HTTP 500 (error del servidor). Esto puede
indicar un error de servicio interno de DAX o un error HTTP 500 en la
tabla subyacente deMétrica de SystemErrors.

Determinar si se ha producido Monitorice ErrorRequestCount para determinar si alguna solicitud


algún error del usuario ha dado lugar a un código HTTP 400 (error del cliente). Si ve que el
número de errores aumenta, tal vez desee investigar y asegurarse
de que envía solicitudes del cliente correctas.

Versión de API 2012-08-10


799
Amazon DynamoDB Guía para desarrolladores
Monitoreo con CloudWatch

¿Cómo...? Métricas relevantes

Determinar si se ha producido Monitorice ItemCacheMisses para determinar el número de veces


algún error de la caché que no se encontró un elemento en la caché, y QueryCacheMisses
y ScanCacheMisses para determinar el número de veces que no se
encontró el resultado de una consulta o examen en la caché.

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.

Por ejemplo, para la caché de elementos, puede utilizar la expresión


m1/SUM([m1, m2])*100, donde m1 es la métrica ItemCacheHits y
m2 es la métrica ItemCacheMisses del clúster. Para las cachés de
consulta y análisis, puede utilizar el mismo patrón con la métrica de
caché de consultas y análisis correspondiente.

Visualización de dimensiones y métricas de DAX DAX


Cuando interactúa con Amazon DynamoDB, este envía métricas y dimensiones a Amazon CloudWatch.
Puede seguir los siguientes procedimientos para ver las métricas de DynamoDB Accelerator (DAX).

Para ver las métricas (consola)

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.

1. Abra la consola de CloudWatch en https://console.aws.amazon.com/cloudwatch/.


2. En el panel de navegación, seleccione Metrics (Métricas).
3. Seleccione el espacio de nombres de DAX.

Para ver las métricas (AWS CLI)

• En el símbolo del sistema, ejecute el siguiente comando.

aws cloudwatch list-metrics --namespace "AWS/DAX"

Métricas y dimensiones de DAX de DAX


En las siguientes secciones se detallan las métricas y dimensiones que DAX envía a CloudWatch.

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

CloudWatch agrega las siguientes métricas de DAX a intervalos de un minuto:

• CPUUtilization
• CacheMemoryUtilization
• NetworkBytesIn
• NetworkBytesOut
• NetworkPacketsIn

Versión de API 2012-08-10


800
Amazon DynamoDB Guía para desarrolladores
Monitoreo con CloudWatch

• 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

CPUUtilization El porcentaje de utilización de CPU del nodo o del clúster.

Unidades:Percent

Estadísticas válidas:

• Minimum
• Maximum
• Average

CacheMemoryUtilization Porcentaje de memoria caché disponible que está utilizando


la caché de elementos y la caché de consultas en el nodo
o clúster. Los datos almacenados en caché comienzan a

Versión de API 2012-08-10


801
Amazon DynamoDB Guía para desarrolladores
Monitoreo con CloudWatch

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

NetworkBytesIn El número de bytes recibidos en todas las interfaces de red por el


nodo o el clúster.

Unidades:Bytes

Estadísticas válidas:

• Minimum
• Maximum
• Average

NetworkBytesOut El número de bytes enviados en todas las interfaces de red por el


nodo o el clúster. Esta métrica identifica el volumen de tráfico de red
saliente en cuanto al número de bytes de un solo nodo o clúster.

Unidades:Bytes

Estadísticas válidas:

• Minimum
• Maximum
• Average

NetworkPacketsIn El número de paquetes recibidos en todas las interfaces de red por


el nodo o el clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average

Versión de API 2012-08-10


802
Amazon DynamoDB Guía para desarrolladores
Monitoreo con CloudWatch

Métrica Descripción

NetworkPacketsOut El número de paquetes enviados en todas las interfaces de red por


el nodo o el clúster. Esta métrica identifica el volumen de tráfico de
red saliente en cuanto al número de paquetes de un solo nodo o
clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average

GetItemRequestCount Número de deGetItemmanejadas por el nodo o el clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

BatchGetItemRequestCount Número de deBatchGetItemmanejadas por el nodo o el clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

BatchWriteItemRequestCount Número de deBatchWriteItemmanejadas por el nodo o el clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

Versión de API 2012-08-10


803
Amazon DynamoDB Guía para desarrolladores
Monitoreo con CloudWatch

Métrica Descripción

DeleteItemRequestCount Número de deDeleteItemmanejadas por el nodo o el clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

PutItemRequestCount Número de dePutItemmanejadas por el nodo o el clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

UpdateItemRequestCount Número de deUpdateItemmanejadas por el nodo o el clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

TransactWriteItemsCount Número de deTransactWriteItemsmanejadas por el nodo o el


clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

Versión de API 2012-08-10


804
Amazon DynamoDB Guía para desarrolladores
Monitoreo con CloudWatch

Métrica Descripción

TransactGetItemsCount Número de deTransactGetItemsmanejadas por el nodo o el


clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

ItemCacheHits Número de veces que el nodo o el clúster devolvió un elemento


desde la caché.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

ItemCacheMisses Número de veces que un elemento no estaba en la caché de nodo


o clúster y tuvo que recuperarse de DynamoDB.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

QueryCacheHits Número de veces que se devolvió un resultado de consulta desde la


caché de nodo o clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

Versión de API 2012-08-10


805
Amazon DynamoDB Guía para desarrolladores
Monitoreo con CloudWatch

Métrica Descripción

QueryCacheMisses Número de veces que un resultado de consulta no estaba en la


caché de nodo o clúster y tuvo que recuperarse de DynamoDB.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

ScanCacheHits Número de veces que se ha devuelto un resultado de análisis


desde la caché de nodo o clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

ScanCacheMisses Número de veces que un resultado de análisis no estaba en la


caché de nodo o clúster y tuvo que recuperarse de DynamoDB.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

TotalRequestCount Número total de solicitudes manejadas por el nodo o el clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

Versión de API 2012-08-10


806
Amazon DynamoDB Guía para desarrolladores
Monitoreo con CloudWatch

Métrica Descripción

ErrorRequestCount Número total de solicitudes que dieron lugar a un error de usuario


notificado por el nodo o el clúster. Se incluyen las solicitudes que
fueron restringidas por el nodo o el clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

ThrottledRequestCount Número total de solicitudes limitadas por el nodo o el clúster. Las


solicitudes que fueron limitadas por DynamoDB no se incluyen y se
pueden supervisar medianteMétricas de DynamoDB (p. 940).

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

FaultRequestCount Número total de solicitudes que dieron lugar a un error interno


notificado por el nodo o el clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

FailedRequestCount El número total de solicitudes que generaron un error notificado por


el nodo o el clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

Versión de API 2012-08-10


807
Amazon DynamoDB Guía para desarrolladores
Monitoreo con CloudWatch

Métrica Descripción

QueryRequestCount El número de solicitudes de consulta manejadas por el nodo o el


clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

ScanRequestCount El número de solicitudes de análisis manejadas por el nodo o el


clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

ClientConnections Número de conexiones simultáneas realizadas por los clientes al


nodo o clúster.

Unidades:Count

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

EstimatedDbSize Una aproximación de la cantidad de datos almacenados en caché


en la caché de elementos y la caché de consultas por el nodo o el
clúster.

Unidades:Bytes

Estadísticas válidas:

• Minimum
• Maximum
• Average

Versión de API 2012-08-10


808
Amazon DynamoDB Guía para desarrolladores
Monitoreo con CloudWatch

Métrica Descripción

EvictedSize La cantidad de datos desalojados por el nodo o el clúster para dejar


espacio para los datos solicitados recientemente. Si la tasa de
faltas aumenta y ve que esta métrica también crece, probablemente
significa que su conjunto de trabajo ha aumentado. Debe considerar
la posibilidad de cambiar a un clúster con un tipo de nodo más
grande.

Unidades:Bytes

Estadísticas válidas:

• Minimum
• Maximum
• Average
• Sum

CPUCreditUsage El número de créditos de CPU gastados por el nodo para la


utilización de CPU. Un crédito de CPU equivale a una vCPU
ejecutándose al 100% de utilización durante un minuto o una
combinación equivalente de unidades de vCPU, utilización y tiempo
(por ejemplo, una vCPU ejecutándose al 50% durante dos minutos
o dos vCPU ejecutándose al 25% durante dos minutos).

Las métricas de créditos de CPU solo están disponibles cada cinco


minutos. Si especifica un periodo superior a cinco minutos, use la
herramientaSumen lugar de la estadísticaAverage.

Unidades:Credits (vCPU-minutes)

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

Versión de API 2012-08-10


809
Amazon DynamoDB Guía para desarrolladores
Monitoreo con CloudWatch

Métrica Descripción

CPUCreditBalance La cantidad de créditos de CPU obtenidos que un nodo ha


acumulado desde que se lanzó o se inició.

Los créditos se acumulan en el saldo de créditos una vez obtenidos


y se eliminan del saldo de créditos cuando se gastan. El saldo
de créditos tiene un límite máximo, determinado por el tamaño
del nodo DAX. Una vez que se ha alcanzado el límite, los nuevos
créditos obtenidos se descartarán.

Los créditos en elCPUCreditBalanceEstán disponibles para que


el nodo los gaste para explotar más allá de su utilización de CPU
por encima de la referencia.

Unidades:Credits (vCPU-minutes)

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

CPUSurplusCreditBalance El número de créditos sobrantes que ha gastado un nodo DAX


cuando se establece el valor deCPUCreditBalancevalor es cero.

El valor de CPUSurplusCreditBalance se compensa con los


créditos de CPU obtenidos. Si el número de créditos sobrantes
supera el número máximo de créditos que el nodo puede ganar en
un periodo de 24 horas, los créditos sobrantes gastados por encima
del máximo implican un cargo adicional.

Unidades:Credits (vCPU-minutes)

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

Versión de API 2012-08-10


810
Amazon DynamoDB Guía para desarrolladores
Monitoreo con CloudWatch

Métrica Descripción

CPUSurplusCreditsCharged La cantidad de créditos sobrantes gastados que no se han


compensado con créditos de CPU obtenido y, por lo tanto, implican
un cargo adicional.

Los créditos sobrantes gastados se cobran cuando los créditos


sobrantes gastados superan el número máximo de créditos que
el nodo puede ganar en un periodo de 24 horas. Los créditos
sobrantes gastados por encima del máximo se cobran al final de la
hora o cuando se termina el nodo.

Unidades:Credits (vCPU-minutes)

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

Note

LaCPUCreditUsage,CPUCreditBalance,CPUSurplusCreditBalance,
yCPUSurplusCreditsChargedsolo están disponibles para nodos T3.

Dimensiones de métricas de DAX

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

Account Proporciona estadísticas agregadas en


DAX
todos los nodos de una cuenta.
Metrics

ClusterId Limita los datos a un clúster.


Cluster
Metrics

ClusterId, NodeId Limita los datos a un nodo dentro de un


ClusterId,
clúster.
NodeId

Crear alarmas de CloudWatch para monitorear DAX


Puede crear una alarma de Amazon CloudWatch que envíe un mensaje de Amazon Simple Notification
Service (Amazon SNS) cuando la alarma cambie de estado. Una alarma vigila una métrica determinada

Versión de API 2012-08-10


811
Amazon DynamoDB Guía para desarrolladores
Monitoreo con 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.

¿Cómo puedo recibir notificaciones sobre estos errores de la caché de consultas?


1. Cree un tema de Amazon SNS,arn:aws:sns:us-west-2:522194210714:QueryMissAlarm.

Para obtener más información, consulteConfigurar Amazon Simple Notificationen laGuía del usuario
de Amazon CloudWatch.
2. Cree la alarma.

aws cloudwatch put-metric-alarm \


--alarm-name QueryCacheMissesAlarm \
--alarm-description "Alarm over query cache misses" \
--namespace AWS/DAX \
--metric-name QueryCacheMisses \
--dimensions Name=ClusterID,Value=myCluster \
--statistic Sum \
--threshold 8 \
--comparison-operator GreaterThanOrEqualToThreshold \
--period 60 \
--evaluation-periods 1 \
--alarm-actions arn:aws:sns:us-west-2:522194210714:QueryMissAlarm

3. Pruebe la alarma.

aws cloudwatch set-alarm-state --alarm-name QueryCacheMissesAlarm --state-reason


"initializing" --state-value OK

aws cloudwatch set-alarm-state --alarm-name QueryCacheMissesAlarm --state-reason


"initializing" --state-value ALARM

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.

¿Cómo puedo recibir notificaciones si las solicitudes producen un error interno en


el clúster?
1. Cree un tema de Amazon SNS,arn:aws:sns:us-west-2:123456789012:notify-on-system-
errors.

Para obtener más información, consulteConfigurar Amazon Simple Notificationen laGuía del usuario
de Amazon CloudWatch.
2. Cree la alarma.

aws cloudwatch put-metric-alarm \


--alarm-name FaultRequestCountAlarm \
--alarm-description "Alarm when a request causes an internal error" \
--namespace AWS/DAX \

Versión de API 2012-08-10


812
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de DAX con DAXAWS CloudTrail

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

aws cloudwatch set-alarm-state --alarm-name FaultRequestCountAlarm --state-reason


"initializing" --state-value OK

aws cloudwatch set-alarm-state --alarm-name FaultRequestCountAlarm --state-reason


"initializing" --state-value ALARM

Registro de operaciones de DAX con DAXAWS


CloudTrail
Amazon DynamoDB Accelerator (DAX) está integrado conAWS CloudTrail, un servicio que proporciona un
registro de las medidas adoptadas por un usuario, un rol o unAWSen DAX.

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

Instancias de ráfagas DAX T3/T2


DAX le permite elegir entre instancias de rendimiento fijo (como R4 y R5) e instancias de rendimiento
burstable (como T2 y T3). Las instancias de rendimiento ampliable proporcionan un nivel básico de
rendimiento de la CPU con la posibilidad de ampliarse por encima del nivel básico cuando sea necesario.

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.

Familia de instancias DAX T2


Las instancias T2 de DAX son instancias de rendimiento ampliables y de uso general que proporcionan
un nivel base de rendimiento de la CPU con posibilidad de ampliarse por encima del nivel básico. Las
instancias T2 son una buena opción para cargas de trabajo de pruebas y desarrollo que necesitan
previsibilidad de precios. Las instancias T2 de DAX se configuran para el modo estándar, lo que significa
que si la instancia se está quedando sin créditos acumulados, la utilización de la CPU se reduce

Versión de API 2012-08-10


813
Amazon DynamoDB Guía para desarrolladores
Familia de instancias de DAX T3

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.

Familia de instancias de DAX T3


Las instancias T3 de DAX son el tipo de instancia ampliable y general, proporcionando un nivel base
de rendimiento de la CPU con posibilidad de ampliar el uso de la CPU en cualquier momento durante el
tiempo que sea necesario. Las instancias T3 ofrecen un conjunto equilibrado de recursos informáticos, de
memoria y de red, y son ideales para cargas de trabajo con un uso moderado de la CPU que experimentan
picos temporales en uso. Las instancias DAX T3 están configuradas para el modo ilimitado, lo que significa
que pueden irrumpirse más allá de la línea base en una ventana de 24 horas por un cargo adicional.
Para obtener más información sobre el modo ilimitado, consulteModo ilimitado 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.

Por ejemplo, undax.t3.smallrecibe créditos de forma continua a una velocidad de 24 créditos de


CPU por hora. Esta capacidad proporciona un rendimiento básico equivalente al 20% de un núcleo de
CPU (20% × 60 minutos = 12 minutos). Si la instancia no utiliza los créditos que recibe, se almacenan
en su saldo de crédito de CPU hasta un máximo de 576 créditos de CPU. Cuandot3.smallnecesita
explotar a más del 20% de un núcleo, extrae de su saldo de crédito de CPU para manejar este aumento
automáticamente.

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.

Control de acceso DAX


El acelerador de DynamoDB (DAX) está diseñado para funcionar conjuntamente con DynamoDB y agregar
de forma transparente una capa de almacenamiento en caché a las aplicaciones. Sin embargo, DAX y
DynamoDB tienen mecanismos distintos de control de acceso. Ambos servicios utilizanAWS Identity and
Access Management(IAM) para implementar sus respectivas políticas de seguridad, pero los modelos de
seguridad de DAX y DynamoDB son distintos.

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

Versión de API 2012-08-10


814
Amazon DynamoDB Guía para desarrolladores
Rol de servicio de IAM para DAX

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.

Rol de servicio de IAM para DAX


Al crear un clúster de DAX, es preciso asociarlo con un rol de IAM. Esto es lo que se denomina rol de
servicio del clúster.

Supongamos que desea crear un nuevo clúster de DAX denominadoDaxCluster01. Podría


crear un rol de servicio denominado DAXServiceRole y asociarlo con DAXCluster01. La política
deDaxServiceRoledefiniría las acciones de DynamoDB queDaxCluster01podría llevar a cabo, en nombre
de los usuarios que interaccionen con elDaxCluster01.

Cuando se crea un rol de servicio, es preciso especificar una relación de confianza


entre DAXServiceRole y el servicio DAX propiamente dicho. Una relación de confianza determina
qué entidades pueden asumir un rol y utilizar sus permisos. A continuación se muestra un ejemplo de
documento de relación de confianza para DAXServiceRole:

{
"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": [
{

Versión de API 2012-08-10


815
Amazon DynamoDB Guía para desarrolladores
Política de IAM para permitir el acceso a un clúster de DAX

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

Política de IAM para permitir el acceso a un clúster de


DAX
Después de crear un clúster de DAX, es preciso conceder permisos a un usuario de IAM para que este
pueda obtener acceso al clúster de DAX.

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.

El siguiente documento de política concede acceso pleno al destinatario en DAXCluster01.

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

Versión de API 2012-08-10


816
Amazon DynamoDB Guía para desarrolladores
Caso práctico: Acceso a DynamoDB y DAX

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.

Caso práctico: Acceso a DynamoDB y DAX


El siguiente escenario puede ayudarle a ampliar sus conocimientos sobre las políticas de IAM para usarlas
con DAX. (Durante el resto de esta sección haremos referencia a este escenario). En el siguiente diagrama
se muestra información general sobre el escenario.

En este escenario, existen las siguientes entidades:

• Un usuario de IAM (Bob).


• Un rol de IAM (BobUserRole). Bob asume este rol en tiempo de ejecución.
• Una política de IAM (BobAccessPolicy). Esta política se adjunta
aBobUserRole.BobAccessPolicydefine los recursos de DynamoDB y DAX queBobUserRoletiene
permiso de acceso a.
• Un clúster DAX (DAXCluster01).
• Un rol de servicio de IAM (DAXServiceRole). Este rol permite aDAXCluster01para obtener acceso a
DynamoDB.
• Una política de IAM (DAXAccessPolicy). Esta política se adjunta
aDAXServiceRole.DAXAccessPolicydefine las API y los recursos de DynamoDB
queDAXCluster01tiene permiso de acceso a.
• Una tabla de DynamoDB (Books).

La combinación de instrucciones de política en BobAccessPolicy y DAXAccessPolicy determina lo


que Bob puede hacer con la tabla Books. Por ejemplo, Bob podría tener acceso aBooksdirectamente
(a través del punto de enlace de DynamoDB), indirectamente (mediante el clúster de DAX) o de las dos
maneras. Además, Bob podría ser capaz de leer datos de Books, de escribir datos en Books o de ambas
cosas.

Versión de API 2012-08-10


817
Amazon DynamoDB Guía para desarrolladores
Acceso a DynamoDB, pero sin acceso con DAX

Acceso a DynamoDB, pero sin acceso con 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).

Acceso de solo lectura a DynamoDB (solo)


Bobpuede acceder a DynamoDB conBobUserRole. La política de IAM adjunta a este rol
(BobAccessPolicy) determina las tablas de DynamoDB queBobUserRolepuede acceder, y qué API
queBobUserRolepuede invocar.

Supongamos que vamos a usar el documento de política siguiente para BobAccessPolicy.

{
"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"
}
]
}

Cuando este documento se adjunta aBobAccessPolicy, permiteBobUserRolepara obtener acceso al


punto de enlace de DynamoDB y llevar a cabo operaciones de solo lectura en elBooksTabla INTO

DAX no aparece en esta política, por lo que el acceso a través de DAX se denegará.

Versión de API 2012-08-10


818
Amazon DynamoDB Guía para desarrolladores
Acceso a DynamoDB y DAX

Acceso de lectura y escritura a DynamoDB (solo)


SiBobUserRolerequiere acceso de lectura/escritura a DynamoDB, la política siguiente podría funcionar.

{
"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á.

Acceso a DynamoDB y DAX

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

Versión de API 2012-08-10


819
Amazon DynamoDB Guía para desarrolladores
Acceso a DynamoDB y DAX

• dax:Query
• dax:Scan
• dax:PutItem
• dax:UpdateItem
• dax:DeleteItem
• dax:BatchWriteItem
• dax:ConditionCheckItem

Lo mismo sucede para la clave de condición dax:EnclosingOperation.

Acceso de solo lectura a DynamoDB y acceso de solo lectura a


DAX
Supongamos que Bob requiere acceso de solo lectura a laBooksde DynamoDB y DAX. La siguiente
política (asociada a BobUserRole) concedería este acceso:

{
"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",

Versión de API 2012-08-10


820
Amazon DynamoDB Guía para desarrolladores
Acceso a DynamoDB y DAX

"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Query",
"dynamodb:Scan"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/Books"
}
]
}

Acceso de lectura y escritura a DynamoDB y acceso de solo


lectura con DAX
Para un rol de usuario determinado, puede proporcionar acceso de lectura y escritura a una tabla de
DynamoDB y también permitir el acceso de solo lectura a través de DAX.

Para Bob, la política de IAM paraBobUserRolenecesitaría permitir acciones de lectura y escritura


de DynamoDB en elBooks, mientras que también admite acciones de solo lectura a través
deDAXCluster01.

El siguiente ejemplo de documento de política para BobUserRole concedería este acceso:

{
"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"
}
]
}

Además,DAXServiceRolerequeriría una política de IAM que permitaDAXCluster01para realizar


acciones de sólo lectura en elBooksTabla INTO

Versión de API 2012-08-10


821
Amazon DynamoDB Guía para desarrolladores
Acceso a DynamoDB y DAX

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

Acceso de lectura y escritura a DynamoDB y acceso de lectura/


escritura a DAX
Ahora, supongamos que Bob requiere acceso de lectura/escritura a laBooks, directamente desde
DynamoDB o indirectamente desdeDAXCluster01. La siguiente política, asociada a BobAccessPolicy,
concedería este acceso:

{
"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"
}
]
}

Versión de API 2012-08-10


822
Amazon DynamoDB Guía para desarrolladores
Acceso a DynamoDB a través de DAX,
pero sin acceso directo a DynamoDB

Además,DAXServiceRolerequeriría una política de IAM que permitaDAXCluster01para realizar


acciones de lectura/escritura en elBooksTabla INTO

{
"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"
}
]
}

Acceso a DynamoDB a través de DAX, pero sin


acceso directo a DynamoDB
En este escenario, Bob puede acceder a laBooksa través de DAX, pero no tiene acceso directo a la tabla
deBooksen DynamoDB. Por lo tanto, cuando Bob recibe acceso a DAX, también recibe acceso a una tabla
de DynamoDB a la que, de otro modo, no podría obtener acceso. Al configurar una política de IAM para
el rol de servicio de DAX, recuerde que cualquier usuario a quien se conceda acceso al clúster de DAX
mediante la política de acceso de usuario recibe también acceso a las tablas especificadas en esa política.
En este caso, BobAccessPolicy obtiene acceso a las tablas especificadas en DAXAccessPolicy.

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

Versión de API 2012-08-10


823
Amazon DynamoDB Guía para desarrolladores
Acceso a DynamoDB a través de DAX,
pero sin acceso directo a DynamoDB

una tabla de DynamoDB mediante DAX, aunque no tiene acceso explícito directo a esa misma tabla en
DynamoDB.

El siguiente documento de política (BobAccessPolicy), asociado a BobUserRole, concedería este


acceso:

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

Junto con lasBobAccessPolicy, los siguientes ejemplos


deDAXAccessPolicyOtorgaBobUserRoleAcceso a la tabla de
DynamoDBBooksaunqueBobUserRoleno puede acceder directamente a laBooksTabla INTO

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

Versión de API 2012-08-10


824
Amazon DynamoDB Guía para desarrolladores
Cifrado DAX en reposo

Cifrado DAX en reposo


El cifrado en reposo de Amazon DynamoDB Accelerator (DAX) proporciona una capa adicional de
protección de datos al ayudarle a proteger los datos del acceso no autorizado al almacenamiento
subyacente. Las políticas de la organización, las normativas industriales o gubernamentales y los
requisitos de conformidad pueden requerir el uso del cifrado en reposo para proteger los datos. Puede
utilizar el cifrado para aumentar la seguridad de datos de las aplicaciones implementadas en la nube.

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.

Familia Node Type

Optimizada para memoria (R4 y R5) dax.r4.large

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

Versión de API 2012-08-10


825
Amazon DynamoDB Guía para desarrolladores
Habilitación del cifrado en reposo
mediante la AWS Management Console

Familia Node Type

Propósito general (T2) dax.t2.small

dax.t2.medium

Important

El cifrado DAX en reposo de no se admite paradax.r3.*tipos de nodo.

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.

Habilitación del cifrado en reposo mediante la AWS


Management Console
Siga estos pasos para habilitar el cifrado DAX en reposo de en una tabla mediante la consola.

Para habilitar el cifrado DAX en reposo de

1. Inicie sesión enAWS Management Consoley abra la consola de DynamoDB enhttps://


console.aws.amazon.com/dynamodb/.
2. En el panel de navegación en el lado izquierdo de la consola, en DAX, elija Clusters (Clústeres).
3. Elija Create cluster.
4. En Cluster name (Nombre del clúster), escriba un nombre abreviado para su clúster. Elija el node type
(tipo de nodo) de todos los nodos del clúster y para el tamaño del clúster, utilice 3 nodos.
5. En Encryption (Cifrado), asegúrese de que Enable encryption (Habilitar el cifrado) esté seleccionado.

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

Cifrado de DAX en tránsito


El Acelerador de Amazon DynamoDB (DAX) admite el cifrado en tránsito de datos entre la aplicación y el
clúster DAX, lo que le permite utilizar DAX en aplicaciones con requisitos de cifrado estrictos.

Independientemente de si elige o no el cifrado en tránsito, el tráfico entre la aplicación y el clúster DAX


permanece en su Amazon VPC. Este tráfico se enruta a las interfaces de red elásticas con IP privadas
de la VPC que están conectadas a los nodos del clúster. Con su VPC como límite de confianza, tiene
un control significativo sobre la seguridad de sus datos mediante el uso de herramientas estándar como

Versión de API 2012-08-10


826
Amazon DynamoDB Guía para desarrolladores
Uso de roles vinculados a servicios para DAX

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.

Uso de roles de IAM vinculados a servicios para


DAX
Amazon DynamoDB Accelerator (DAX) 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 DAX. Los roles vinculados a servicios están predefinidos por DAX e incluyen todos los permisos que el
servicio requiere para llamar a otrosAWSServicios de en su nombre.

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)

Permisos de roles vinculados a servicios para DAX


DAX usa la función vinculada al servicio denominadaAWSServiceRoleForDAX. Este rol permite a DAX
llamar a servicios en nombre del clúster DAX.

Versión de API 2012-08-10


827
Amazon DynamoDB Guía para desarrolladores
Creación de un rol vinculado a un servicio para DAX

Important

LaAWSServiceRoleForDAXEl rol vinculado a un servicio simplifica la configuración y


mantenimiento de un clúster de DAX. Sin embargo, debe conceder acceso a cada clúster a
DynamoDB para poder usarlo. Para obtener más información, consulte Control de acceso
DAX (p. 814).

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"}}
}

Creación de un rol vinculado a un servicio para DAX


No necesita crear manualmente un rol vinculado a un servicio. Al crear un clúster, DAX crea el rol
vinculado al servicio por usted.

Versión de API 2012-08-10


828
Amazon DynamoDB Guía para desarrolladores
Edición de un rol vinculado a un servicio para DAX

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.

Edición de un rol vinculado a un servicio para DAX


DAX no le permite editar elAWSServiceRoleForDAXRol vinculado al 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 DAX


Si ya no necesita utilizar una característica o servicio que requiere un rol vinculado a un servicio, le
recomendamos que elimine dicho rol. De esta forma no tiene una entidad no utilizada que no se monitorice
ni mantenga de forma activa. Sin embargo, debe eliminar todos los clústeres de DAX para poder eliminar el
rol vinculado al servicio.

Limpiar un rol vinculado a un servicio


Para poder utilizar IAM para eliminar un rol vinculado al servicio, primero debe confirmar que dicho rol no
tiene sesiones activas y eliminar los recursos que utiliza.

Para comprobar si el rol vinculado al servicio tiene una sesión activa en la consola de IAM

1. Inicie sesión en la AWS Management Console y abra la consola de IAM en https://


console.aws.amazon.com/iam/.
2. En el panel de navegación de la consola de IAM, elija Roles. A continuación, seleccione el nombre (no
la casilla de verificación) delAWSServiceRoleforDAXRol de .
3. En la página Summary del rol seleccionado, elija la pestaña Access Advisor.
4. En la pestaña Access Advisor, revise la actividad reciente del rol vinculado al servicio.
Note

Si no está seguro de si DAX está utilizando el métodoAWSServiceRoleForDAXPuede


intentar eliminar el rol para comprobarlo. Si el servicio está utilizando el rol, este no podrá
eliminarse, y podrá ver las regiones en las que se está utilizando. Si el rol se está utilizando,
debe eliminar sus clústeres de DAX para poder eliminarlo. No se puede revocar la sesión de
un rol vinculado a un servicio.

Si desea eliminar la funciónAWSServiceRoleForDAX, primero debe eliminar todos los clústeres de DAX.

Eliminación de todos los clústeres de DAX


Use alguno de estos procedimientos para eliminar cada uno de sus clústeres de DAX.

Para eliminar un clúster de DAX (consola)

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.

Versión de API 2012-08-10


829
Amazon DynamoDB Guía para desarrolladores
Acceso a DAX a través deAWSCuentas

2. En el panel de navegación, en DAX, elija Clusters (Clústeres).


3. Elija Actions (Acciones) y, a continuación, Delete (Eliminar).
4. En el recuadro Delete cluster confirmation (Eliminar confirmación de clúster), elija Delete (Eliminar).

Para eliminar un clúster de DAX (AWS CLI)

Consultedelete-clusteren laAWS CLIReferencia de los comandos de la.

Para eliminar un clúster de DAX (API)

ConsulteDeleteClusteren laReferencia de la API de Amazon DynamoDB.

Eliminación del rol vinculado a servicio


Para eliminar manualmente el rol vinculado a un servicio mediante IAM

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.

Acceso a DAX a través deAWSCuentas


Imagine que tiene un clúster de DynamoDB Accelerator (DAX) ejecutándose en unAWS(cuenta A) y el
clúster de DAX debe ser accesible desde una instancia Amazon Elastic Compute Cloud (Amazon EC2)
de otra cuenta deAWScuenta (cuenta B). En este tutorial, puede lograr esto iniciando una instancia EC2
en la cuenta B con un rol de IAM desde la cuenta B. Utilice las credenciales de seguridad temporales
de la instancia EC2 para asumir un rol de IAM desde la cuenta A. Por último, utilice las credenciales de
seguridad temporales de asumir el rol de IAM en la cuenta A para realizar llamadas de aplicación a través
de una conexión de interconexión de Amazon VPC al clúster DAX de la cuenta A. Para realizar estas
tareas, necesitará acceso administrativo tanto enAWSCuentas.

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

Versión de API 2012-08-10


830
Amazon DynamoDB Guía para desarrolladores
Configurar IAM

2. En la cuenta B, cree un rol que Amazon EC2 pueda utilizar al lanzar instancias.

aws iam create-role \


--role-name AssumeDaxRole \
--assume-role-policy-document file://AssumeDaxRoleTrust.json

3. Cree un archivo de texto denominadoAssumeDaxRolePolicy.jsonReemplace el contenido


siguiente, que permite que el código que se ejecuta en la instancia EC2 en la cuenta B asuma un rol
de IAM en la cuenta A.accountACon el ID real de la cuenta A.

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::accountA:role/DaxCrossAccountRole"
}
]
}

4. Agregue esa política al rol que acaba de crear.

aws iam put-role-policy \


--role-name AssumeDaxRole \
--policy-name AssumeDaxRolePolicy \
--policy-document file://AssumeDaxRolePolicy.json

5. Cree un perfil de instancia para permitir que las instancias utilicen el rol.

aws iam create-instance-profile \


--instance-profile-name AssumeDaxInstanceProfile

6. Asocie el rol con el perfil de instancia.

aws iam add-role-to-instance-profile \


--instance-profile-name AssumeDaxInstanceProfile \
--role-name AssumeDaxRole

7. Cree un archivo de texto denominado DaxCrossAccountRoleTrust.json con el siguiente


contenido, lo que permite a la cuenta B asumir un rol de cuenta A. Reemplace cuentaB por el ID real
de la cuenta B.

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::accountB:role/AssumeDaxRole"
},
"Action": "sts:AssumeRole"
}
]
}

8. En la cuenta A, cree el rol que la cuenta B puede asumir.

aws iam create-role \

Versión de API 2012-08-10


831
Amazon DynamoDB Guía para desarrolladores
Configurar una VPC

--role-name DaxCrossAccountRole \
--assume-role-policy-document file://DaxCrossAccountRoleTrust.json

9. Cree un archivo de texto denominadoDaxCrossAccountPolicy.jsonque permite el acceso al


clúster de DAX. Reemplazardax-cluster-arnCon el nombre de recurso de Amazon (ARN) correcto
de su clúster de DAX.

{
"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"
}
]
}

10. En la cuenta A, agregue la política al rol.

aws iam put-role-policy \


--role-name DaxCrossAccountRole \
--policy-name DaxCrossAccountPolicy \
--policy-document file://DaxCrossAccountPolicy.json

Configurar una VPC


1. Busque el grupo de subred del clúster de DAX de la cuenta A. Reemplazarcluster-namePor el
nombre del clúster de DAX al que debe tener acceso la cuenta B.

aws dax describe-clusters \


--cluster-name cluster-name
--query 'Clusters[0].SubnetGroup'

2. Utilizando ese grupo de subred, busque la VPC del clúster.

aws dax describe-subnet-groups \


--subnet-group-name subnet-group \
--query 'SubnetGroups[0].VpcId'

3. Usando ese vpc-id, busque el CIDR de la VPC.

aws ec2 describe-vpcs \


--vpc vpc-id \
--query 'Vpcs[0].CidrBlock'

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.

Versión de API 2012-08-10


832
Amazon DynamoDB Guía para desarrolladores
Configurar una VPC

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.

aws ec2 describe-route-tables \


--filters 'Name=vpc-id,Values=vpc-id' \
--query 'RouteTables[0].RouteTableId'

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.

aws ec2 create-route \


--route-table-id accountB-route-table-id \
--destination-cidr accountA-vpc-cidr \
--vpc-peering-connection-id peering-connection-id

8. En la cuenta A, busque la tabla de ruteo del clúster de DAX mediante elvpc-c-c-c-cque encontraste
anteriormente.

aws ec2 describe-route-tables \


--filters 'Name=vpc-id, Values=accountA-vpc-id' \
--query 'RouteTables[0].RouteTableId'

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.

aws ec2 create-route \


--route-table-id accountA-route-table-id \
--destination-cidr accountB-vpc-cidr \
--vpc-peering-connection-id peering-connection-id

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.

aws dax describe-clusters \


--cluster-name cluster-name \
--query 'Clusters[0].SecurityGroups[0].SecurityGroupIdentifier'

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.

aws ec2 authorize-security-group-ingress \


--group-id accountA-security-group-id \
--protocol tcp \
--port 8111 \
--source-group accountB-security-group-id \
--group-owner accountB-id

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.

Versión de API 2012-08-10


833
Amazon DynamoDB Guía para desarrolladores
Modificar el cliente de DAX para
permitir el acceso de entre cuentas

Modificar el cliente de DAX para permitir el acceso de


entre cuentas
Note

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!"

1. Agregue las siguientes importaciones:

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

STSAssumeRoleSessionCredentialsProvider credentials = new


STSAssumeRoleSessionCredentialsProvider.Builder("arn:aws:iam::accountA:role/
RoleName", "TryDax")
.withStsClient(awsSecurityTokenService)
.build();

DynamoDB client = AmazonDaxClientBuilder.standard()


.withRegion(region)
.withEndpointConfiguration(dax_endpoint)
.withCredentials(credentials)
.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!"

1. Agregue el paquete NuGet AWSSDK.SecurityToken a la solución.

<PackageReference Include="AWSSDK.SecurityToken" Version="latest version" />

2. Utilice los paquetes SecurityToken y SecurityToken.Model.

using Amazon.SecurityToken;

Versión de API 2012-08-10


834
Amazon DynamoDB Guía para desarrolladores
Modificar el cliente de DAX para
permitir el acceso de entre cuentas

using Amazon.SecurityToken.Model;

3. Obtenga credenciales temporales de AmazonSimpleTokenService y cree un objeto de


ClusterDaxClient. Recuerde reemplazar cada marcador de posición de entrada de
usuario por los valores correctos para sus cuentas.

IAmazonSecurityTokenService sts = new AmazonSecurityTokenServiceClient();

var assumeRoleResponse = sts.AssumeRole(new AssumeRoleRequest


{
RoleArn = "arn:aws:iam::accountA:role/RoleName",
RoleSessionName = "TryDax"
});

Credentials credentials = assumeRoleResponse.Credentials;

var clientConfig = new DaxClientConfig(dax_endpoint, port)


{
AwsCredentials = assumeRoleResponse.Credentials

};

var client = new ClusterDaxClient(clientConfig);

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.

1. Importe los paquetes de AWS STS y de sesión.

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

2. Obtenga las credenciales temporales deAmazonSimpleTokenServicey cree un objeto cliente


DAX. Recuerde reemplazar cada marcador de posición de entrada de usuario por los
valores correctos para sus cuentas.

sess, err := session.NewSession(&aws.Config{


Region: aws.String(region)},
)
if err != nil {
return nil, err
}

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)

Versión de API 2012-08-10


835
Amazon DynamoDB Guía para desarrolladores
Modificar el cliente de DAX para
permitir el acceso de entre cuentas

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

2. Obtenga credenciales temporales de sts y cree un objeto AmazonDaxClient. Recuerde


reemplazar cada marcador de posición de entrada de usuario por los valores
correctos para sus cuentas.

sts = boto3.client('sts')
stsresponse =
sts.assume_role(RoleArn='arn:aws:iam::accountA:role/
RoleName',RoleSessionName='tryDax')
credentials = botocore.session.get_session()['Credentials']

dax = amazondax.AmazonDaxClient(session, region_name=region,


endpoints=[dax_endpoint], aws_access_key_id=credentials['AccessKeyId'],
aws_secret_access_key=credentials['SecretAccessKey'],
aws_session_token=credentials['SessionToken'])
client = dax

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.

const AmazonDaxClient = require('amazon-dax-client');


const AWS = require('aws-sdk');
const region = 'region';
const endpoints = [daxEndpoint1, ...];

const getCredentials = async() => {


return new Promise((resolve, reject) => {
const sts = new AWS.STS();
const roleParams = {
RoleArn: 'arn:aws:iam::accountA:role/RoleName',
RoleSessionName: 'tryDax',
};
sts.assumeRole(roleParams, (err, session) => {
if(err) {
reject(err);
} else {
resolve({
accessKeyId: session.Credentials.AccessKeyId,
secretAccessKey: session.Credentials.SecretAccessKey,
sessionToken: session.Credentials.SessionToken,
});
}
});
});

Versión de API 2012-08-10


836
Amazon DynamoDB Guía para desarrolladores
Guía de tamaño de clúster de DAX

};

const createDaxClient = async() => {


const credentials = await getCredentials();
const daxClient = new AmazonDaxClient({endpoints: endpoints, region: region,
accessKeyId: credentials.accessKeyId, secretAccessKey: credentials.secretAccessKey,
sessionToken: credentials.sessionToken});
return new AWS.DynamoDB.DocumentClient({service: daxClient});
};

createDaxClient().then((client) => {
client.get(...);
...
}).catch((error) => {
console.log('Caught an error: ' + error);
});

Guía de tamaño de clúster de DAX


Esta guía proporciona consejos para elegir un tamaño de clúster de Amazon DynamoDB (DAX) y un tipo
de nodo adecuados para su aplicación. Estas instrucciones le guiarán a través de los pasos necesarios
para estimar el tráfico de DAX de su aplicación, seleccionar una configuración de clúster y probarla.

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.

El proceso suele seguir estos pasos:

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.

Estimación del tráfico


Hay tres factores principales que caracterizan una carga de trabajo típica de DAX:

Versión de API 2012-08-10


837
Amazon DynamoDB Guía para desarrolladores
Prueba de carga

• Tasa de aciertos de caché


• Unidades de capacidad de lectura (p. 351) (RCU) por segundo
• Unidades de capacidad de escritura (p. 352) (WCU) por segundo

Estimación de la tasa de aciertos de caché


Si ya tiene un clúster de DAX, puede utilizar la herramientaItemCacheHitsyItemCacheMisses
Métricas de Amazon CloudWatch (p. 800)para determinar la tasa de aciertos de caché. La tasa de
aciertos de caché es igual a ItemCacheHits / (ItemCacheHits + ItemCacheMisses). Si la carga
de trabajo incluye operaciones Query o Scan, también debe consultar las métricas QueryCacheHits,
QueryCacheMisses, ScanCacheHits y ScanCacheMisses. Las tasas de aciertos de caché varían de
una aplicación a otra y están muy influenciadas por la configuración de Tiempo de vida (TTL) del clúster.
Las tasas de aciertos típicas para las aplicaciones que utilizan DAX son del 85 al 95 por ciento.

Estimación de unidades de capacidad de lectura y escritura


Si ya tiene tablas de DynamoDB para su aplicación, observe
laConsumedReadCapacityUnitsyConsumedWriteCapacityUnits Métricas de
CloudWatch (p. 800). Utilice la estadística Sum y divida por el número de segundos del período.

Si también tiene un clúster de DAX, recuerDynamoDBConsumedReadCapacityUnitssólo cuenta para


errores de caché. Por lo tanto, para tener una idea de las unidades de capacidad de lectura por segundo
manejadas por su clúster de DAX, divida el número por su tasa de errores de caché (es decir, 1 - tasa de
aciertos de caché).

Si aún no tiene una tabla de DynamoDB, consulte la documentación sobreUnidades de capacidad de


lectura (p. 351)yunidades de capacidad de escritura (p. 352)Para estimar el tráfico en función de la tasa
de solicitudes estimada de la aplicación, los elementos a los que se accede por solicitud y el tamaño del
elemento.

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.

Versión de API 2012-08-10


838
Amazon DynamoDB Guía para desarrolladores
Referencia de la API

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.

Versión de API 2012-08-10


839
Amazon DynamoDB Guía para desarrolladores
Descargar

NoSQL Workbench para DynamoDB


NoSQL Workbench para Amazon DynamoDB es una aplicación de interfaz gráfica de usuario de cliente
multiplataforma para el desarrollo moderno de bases de datos y operaciones, y está disponible para
Windows, macOS y Linux. NoSQL Workbench es una herramienta IDE visual unificada que proporciona
características de modelado de datos, visualización de datos y desarrollo de consultas para ayudarle a
diseñar, crear, consultar y administrar tablas de 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)

Descargar NoSQL Workbench


Siga estas instrucciones para descargar e instalar NoSQL Workbench para Amazon DynamoDB.

Para descargar e instalar NoSQL Workbench

1. Descargue la versión apropiada de NoSQL Workbench para su sistema operativo.

Versión de API 2012-08-10


840
Amazon DynamoDB Guía para desarrolladores
Modelador de datos

Sistema operativo Enlace de descarga Enlace de suma de


comprobación

macOS Descargar para macOS Suma de comprobación

Windows Descargar para Windows Suma de comprobación

Linux* Descarga para Linux Suma de comprobación

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

Creación de modelos de datos con NoSQL


Workbench
Puede utilizar la herramienta del modelador de datos de NoSQL Workbench para Amazon DynamoDB para
crear nuevos modelos de datos o para diseñar modelos basados en otros existentes que satisfagan los
patrones de acceso a datos de sus aplicaciones. El modelador de datos incluye algunos modelos de datos
de muestra para ayudarle a comenzar.

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)

Creación de un nuevo modelo de datos


Siga estos pasos para crear un nuevo modelo de datos en Amazon DynamoDB utilizando NoSQL
Workbench.

Para crear un nuevo modelo de datos

1. Abra NoSQL Workbench y, en el panel de navegación de la izquierda, elija el icono Data modeler
(Modelador de datos).

Versión de API 2012-08-10


841
Amazon DynamoDB Guía para desarrolladores
Creación de un nuevo modelo

2. Elija Create data model (Crear modelo 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).

Versión de API 2012-08-10


842
Amazon DynamoDB Guía para desarrolladores
Creación de un nuevo modelo

Para obtener más información sobre las tablas, consulte Uso de tablas en DynamoDB.
5. Especifique lo siguiente:

• Nombre de la tablaEscriba un nombre único para la tabla.


• Clave de partición— Introduzca un nombre de clave de partición y especifique su tipo.
• Si desea añadir una clave de ordenación:
1. Seleccione Add sort key (Añadir clave de ordenación).
2. Especifique el nombre de la clave de ordenación y su tipo.
3.

6. Para añadir otros atributos, haga lo siguiente por cada uno:

1. Elija Add other attribute (Añadir otro atributo).


2. Especifique el nombre y el tipo de atributo.

Versión de API 2012-08-10


843
Amazon DynamoDB Guía para desarrolladores
Creación de un nuevo modelo

7. Agregar una faceta:


Note

FacetasRepresentan los diferentes patrones de acceso a datos de una aplicación para


DynamoDB.

• Seleccione Add facets (Agregar facetas).


• Elija Add facet (Agregar faceta).

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

Elija Add facet (Agregar faceta).

Versión de API 2012-08-10


844
Amazon DynamoDB Guía para desarrolladores
Creación de un nuevo modelo

Repita el paso 8 si desea añadir más facetas.


8. Si desea añadir un índice secundario global, elija Add global secondary index (Añadir índice
secundario global).

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.

Versión de API 2012-08-10


845
Amazon DynamoDB Guía para desarrolladores
Creación de un nuevo modelo

9. De forma predeterminada, la tabla utilizará el modo de capacidad aprovisionada con el escalado


automático habilitado en la capacidad de lectura y escritura. Si desea cambiar esta configuración,
desactive la casilla «Configuración predeterminada» enConfiguración de capacidad.

Seleccione el modo de capacidad deseado, la capacidad de lectura y escritura y el rol de IAM de


escalado automático (si corresponde).

Versión de API 2012-08-10


846
Amazon DynamoDB Guía para desarrolladores
Creación de un nuevo modelo

Versión de API 2012-08-10


847
Amazon DynamoDB Guía para desarrolladores
Importación de un modelo existente

Para obtener más información sobre la configuración de capacidad de DynamoDB, consulte.Modo de


capacidad de lectura/escritura (p. 18).
10. Elija Add table definition (Añadir definición de tabla).

Para obtener más información acerca de laCreateTableoperación de la API, consulteCreateTableen


laReferencia de la API de Amazon DynamoDB.

Importación de un modelo de datos existente


Puede utilizar NoSQL Workbench para Amazon DynamoDB para crear un modelo de datos mediante la
importación y la modificación de un modelo existente. Puede importar modelos de datos en formato de
modelo de NoSQL Workbench o enAWS CloudFormationFormato de plantilla JSON.

Para importar un modelo de datos

1. En NoSQL Workbench, en el panel de navegación de la izquierda, seleccione el icono Data modeler


(Modelador de datos).

2. Pase el ratón sobreImportación del modelo de datos.

Versión de API 2012-08-10


848
Amazon DynamoDB Guía para desarrolladores
Importación de un modelo existente

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.

3. Elija un modelo para importar.

Versión de API 2012-08-10


849
Amazon DynamoDB Guía para desarrolladores
Importación de un modelo existente

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.

Versión de API 2012-08-10


850
Amazon DynamoDB Guía para desarrolladores
Exportación de un modelo

Exportación de un modelo de datos


Después de crear un modelo de datos utilizando NoSQL Workbench para Amazon DynamoDB, puede
guardarlo y exportarlo en formato de modelo NoSQL Workbench oAWS CloudFormationFormato de
plantilla JSON.

Para exportar un modelo de datos

1. En NoSQL Workbench, en el panel de navegación de la izquierda, seleccione el icono Data modeler


(Modelador de datos).

Versión de API 2012-08-10


851
Amazon DynamoDB Guía para desarrolladores
Exportación de un modelo

2. Pase el ratón sobreExportar 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.

3. Elija una ubicación para guardar el modelo.

Versión de API 2012-08-10


852
Amazon DynamoDB Guía para desarrolladores
Edición de un modelo existente

Edición de un modelo de datos existente


Para editar un modelo existente

1. En NoSQL Workbench, en el panel de navegación de la izquierda, seleccione el botón Data modeler


(Modelador de datos).

2. Elija la tabla que desea editar.

Versión de API 2012-08-10


853
Amazon DynamoDB Guía para desarrolladores
Edición de un modelo existente

Elija Edit.

3. Realice las ediciones necesarias y, a continuación, seleccione Save edits (Guardar ediciones).

Para editar manualmente un modelo existente y agregar una faceta

1. Exporte el modelo. Para obtener más información, consulte Exportación de un modelo de


datos (p. 851).
2. Abra el archivo exportado en un editor.
3. Localice el objeto DataModel de la tabla para la que desea crear una faceta.

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"
},

Versión de API 2012-08-10


854
Amazon DynamoDB Guía para desarrolladores
Visualizador de datos

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

Visualización de patrones de acceso a datos


Puede utilizar la herramienta de visualización en NoSQL Workbench para Amazon DynamoDB para con
el fin de mapear consultas y visualizar diferentes patrones de acceso (conocidos comoFacetas) de una
aplicación. Cada faceta corresponde a un patrón de acceso diferente en DynamoDB. También puede
añadir datos manualmente a su modelo de datos o importar datos desde MySQL.

Temas
• Incorporación de datos de muestreo a un modelo de datos (p. 856)

Versión de API 2012-08-10


855
Amazon DynamoDB Guía para desarrolladores
Incorporación de datos de muestra

• Visualización de patrones de acceso a datos (p. 857)


• Visualización de todas las tablas de un modelo de datos utilizando la vista agregada (p. 858)
• Confirmación de un modelo de datos en DynamoDB (p. 859)

Incorporación de datos de muestreo a un modelo de


datos
Al agregar datos de muestra a su modelo, puede mostrar datos al visualizar el modelo y sus diversos
patrones de acceso a datos o facetas.

Siga estos pasos para agregar datos de muestra a un modelo de datos utilizando NoSQL Workbench para
Amazon DynamoDB.

Para añadir datos de muestra

1. En el panel de navegación de la izquierda, elija el icono visualizer (visualizador).

2. En el visualizador, elija Update (Actualizar) junto al nombre de tabla.

Versión de API 2012-08-10


856
Amazon DynamoDB Guía para desarrolladores
Facetas

3. Elija Add Data (Añadir datos).

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

Visualización de patrones de acceso a datos


En NoSQL Workbench,Facetasrepresentan los diferentes patrones de acceso a los datos de una
aplicación de Amazon DynamoDB.

Para ver información sobre facetas en NoSQL Workbench

1. En el panel de navegación de la izquierda, elija el icono visualizer (visualizador).

Versión de API 2012-08-10


857
Amazon DynamoDB Guía para desarrolladores
Vista agregada

2. En el modelo de datos de la izquierda, seleccione la tabla que desee ver.


3. Elija la flecha desplegable Facets (Facetas) para la tabla seleccionada.
4. En la lista, elija la faceta que desea ver.

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

Visualización de todas las tablas de un modelo de


datos utilizando la vista agregada
La vista agregada en NoSQL Workbench para Amazon DynamoDB representa todas las tablas de un
modelo de datos. Para cada tabla, aparece la siguiente información:

• Nombres de las columnas de la tabla.


• Datos de ejemplo.
• Todos los índices secundarios globales asociados a la tabla. Para cada índice se muestra la siguiente
información:
• Nombres de las columnas del índice
• Datos de ejemplo

Versión de API 2012-08-10


858
Amazon DynamoDB Guía para desarrolladores
Confirmación de un modelo de datos

Para ver toda la información de la tabla

1. En el panel de navegación de la izquierda, elija el icono visualizer (visualizador).

2. En el visualizador, elija Aggregate view (Vista agregada).

Confirmación de un modelo de datos en DynamoDB


Cuando esté satisfecho con su modelo de datos, puede confirmar el modelo en Amazon DynamoDB.
Note

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

Versión de API 2012-08-10


859
Amazon DynamoDB Guía para desarrolladores
Confirmación de un modelo de datos

Para confirmar un modelo de datos en DynamoDB

1. En el panel de navegación de la izquierda, elija el icono visualizer (visualizador).

2. Elija Commit to DynamoDB (Confirmar en DynamoDB).

Versión de API 2012-08-10


860
Amazon DynamoDB Guía para desarrolladores
Confirmación de un modelo de datos

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 añadir una nueva conexión, especifique la siguiente información:


• Account Alias (Alias de cuenta)
• AWS Región
• ID de clave de acceso
• Clave de acceso secreta

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

Versión de API 2012-08-10


861
Amazon DynamoDB Guía para desarrolladores
Confirmación de un modelo de datos

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

Versión de API 2012-08-10


862
Amazon DynamoDB Guía para desarrolladores
Confirmación de un modelo de datos

Versión de API 2012-08-10


863
Amazon DynamoDB Guía para desarrolladores
Generador de operaciones

Exploración de conjuntos de datos y creación de


operaciones con NoSQL Workbench
NoSQL Workbench para Amazon DynamoDB proporciona una completa interfaz gráfica de usuario para
desarrollar y probar consultas. Puede utilizar el generador de operaciones en NoSQL Workbench para ver,
explorar y consultar conjuntos de datos. También puede utilizar el generador de operaciones estructuradas
para crear y realizar operaciones de plano de datos, con compatibilidad con proyección y expresión de
condiciones, y generar código de muestra en varios idiomas.

Temas
• Exploración de conjuntos de datos (p. 864)
• Generación de operaciones complejas (p. 868)

Exploración de conjuntos de datos


Para explorar las tablas de Amazon DynamoDB, primero necesita conectarse a suAWSaccount.

Para añadir una conexión a su base de datos

1. En NoSQL Workbench, en el panel de navegación de la izquierda, seleccione el icono Operation


builder (Generador de operaciones).

2. Elija Add connection (Añadir conexión).

3. Especifique la siguiente información:

Versión de API 2012-08-10


864
Amazon DynamoDB Guía para desarrolladores
Exploración de conjuntos de datos

• Account Alias (Alias de cuenta)


• AWS Región
• ID de clave de acceso
• Clave de acceso secreta

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
4. Elija Connect.

Versión de API 2012-08-10


865
Amazon DynamoDB Guía para desarrolladores
Exploración de conjuntos de datos

Si no desea registrarse para obtener una cuenta de la capa gratuita, puede configurar y prefiere usar
DynamoDB Local (versión descargable).

a. Elija la pestaña Local en la pantalla de conexión


b. Especifique la siguiente información:

• Connection name (Nombre de la conexión)


• Puerto
c. Seleccione el botón Connect (Conectar).

Versión de API 2012-08-10


866
Amazon DynamoDB Guía para desarrolladores
Exploración de conjuntos de datos

5. En la conexión creada, elija Open (Abrir).

Versión de API 2012-08-10


867
Amazon DynamoDB Guía para desarrolladores
Generación de operaciones

Después de conectarse a su base de datos de DynamoDB, la lista de tablas disponibles aparece en el


panel izquierdo. Elija una de las tablas para devolver una muestra de los datos almacenados en la tabla.

Ahora puede ejecutar consultas en la tabla seleccionada.

Para ejecutar consultas en una tabla

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.

Generación de operaciones complejas


El generador de operaciones en NoSQL Workbench para Amazon DynamoDB proporciona una interfaz
visual donde puede realizar operaciones complejas de planos de datos. Incluye compatibilidad con
expresiones de proyección y de condición. También puede elegir la generación de código de muestra para
estas operaciones en varios idiomas.

NoSQL Workbench admite la creaciónPartiQLpara instrucciones DynamoDB, que le permite interactuar


con Dynamodb utilizando un lenguaje de consulta compatible con SQL. NoSQL Workbench también admite
la creación de operaciones de la API CRUD de 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)

Versión de API 2012-08-10


868
Amazon DynamoDB Guía para desarrolladores
Generación de operaciones

• Creación de operaciones de API (p. 872)

Creación de sentencias PartiQL


Para utilizar NoSQL Workbench para crearPartiQL para DynamoDBInstrucciones elegirOperaciones
PartiQLEn la esquina superior derecha de NoSQL Workbench.

Puede generar los siguientes tipos de instrucciones PartiQL en el generador de operaciones.

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

a. SeleccionarParámetros de solicitudes opcionales.


b. SeleccionarPara añadir parámetros nuevos.
c. Introduzca el tipo de atributo y el valor
d. Si desea añadir parámetros adicionales, repita los pasos b y c.
4. Si desea generar código, seleccione Generate code (Generar código).

Seleccione el idioma que desee en las pestañas mostradas. Ahora puede copiar este código y
utilizarlo en su aplicación.

Versión de API 2012-08-10


869
Amazon DynamoDB Guía para desarrolladores
Generación de operaciones

5. Si desea que la operación se ejecute inmediatamente, seleccioneEjecución de.

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

Las operaciones de lectura y escritura no se admiten en la misma solicitud de transacción


PartiQL. Una instrucción SELECT no puede estar en la misma solicitud con las instrucciones
INSERT, UPDATE y DELETE. ConsulteRealización de transacciones con PartiQL para
DynamoDBpara obtener más información.
4. Si su declaración utiliza parámetros

a. SeleccionarParámetros de solicitudes opcionales.


b. SeleccionarPara añadir parámetros nuevos.
c. Introduzca el tipo de atributo y el valor
d. Si desea añadir parámetros adicionales, repita los pasos b y c.
5. Si desea añadir más instrucciones repita los pasos 2 a 4.
6. Si desea generar código, seleccione Generate code (Generar código).

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.

Versión de API 2012-08-10


870
Amazon DynamoDB Guía para desarrolladores
Generación de operaciones

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

a. SeleccionarParámetros de solicitudes opcionales.


b. SeleccionarPara añadir parámetros nuevos.
c. Introduzca el tipo de atributo y el valor
d. Si desea añadir parámetros adicionales, repita los pasos b y c.
5. Si desea añadir más instrucciones repita los pasos 2 a 4.
6. Si desea generar código, seleccione Generate code (Generar código).

Versión de API 2012-08-10


871
Amazon DynamoDB Guía para desarrolladores
Generación de operaciones

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.

Creación de operaciones de API


Para utilizar NoSQL Workbench para crear API CRUD de DynamoDB, elijaOperaciones basadas en la
interfazEn la esquina superior derecha de NoSQL Workbench.

SeleccionarOperaciones de plano de datos deSeleccione el menú desplegable, y, a continuación, elija la


operación que desee crear.

Puede realizar las siguientes operaciones en el generador de operaciones.

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.

1. Especifique el valor de la clave de partición.


2. Si desea añadir una expresión de proyección, haga lo siguiente:

Versión de API 2012-08-10


872
Amazon DynamoDB Guía para desarrolladores
Generación de operaciones

a. SeleccionarExpresiones de proyección.
b. Elija el icono+(signo más) junto aExpresiones de proyección.
c. Especifique la propiedadNombre de atributo,.

3. Si desea generar código, seleccione Generate code (Generar código).

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.

1. Especifique el valor de la clave de partición.


2. Especifique el valor de la clave de clasificación, si existe.
3. Si desea añadir atributos que no sean de clave, haga lo siguiente:

a. Elija + (signo más) junto a Other attributes (Otros atributos).


b. Especifique los valores de Attribute name (Nombre de atributo), Type (Tipo) y Value (Valor).
4. Si debe satisfacerse una expresión de condición para que la operación Put Item se realice
correctamente, haga lo siguiente:

a. Elija Condition (Condición).


b. Especifique el nombre de atributo, el operador de comparación, el tipo de atributo y el valor de
atributo.
c. Si se necesitan otras condiciones, seleccione Condition (Condición) de nuevo.

Para obtener más información, consulte Expresiones de condición (p. 428).

Versión de API 2012-08-10


873
Amazon DynamoDB Guía para desarrolladores
Generación de operaciones

5. Si desea generar código, seleccione Generate code (Generar código).

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:

1. Escriba el valor de la clave de partición.


2. Escriba el valor de la clave de clasificación, si hay una.
3. En Update expression (Actualizar expresión), elija la expresión de la lista.
4. Elija + (signo más) para la expresión.
5. Escriba el nombre y el valor del atributo para la expresión seleccionada.
6. Si desea añadir más expresiones, elija otra de la lista desplegable Update Expression (Actualizar
expresión) y, a continuación, seleccione +.
7. Si debe satisfacerse una expresión de condición para que la operación Update Item se realice
correctamente, haga lo siguiente:

a. Elija Condition (Condición).


b. Especifique el nombre de atributo, el operador de comparación, el tipo de atributo y el valor de
atributo.
c. Si se necesitan otras condiciones, seleccione Condition (Condición) de nuevo.

Para obtener más información, consulte Expresiones de condición (p. 428).

Versión de API 2012-08-10


874
Amazon DynamoDB Guía para desarrolladores
Generación de operaciones

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

1. Escriba el valor de la clave de partición.


2. Escriba el valor de la clave de clasificación, si hay una.
3. Si debe satisfacerse una expresión de condición para que la operación Delete Item se realice
correctamente, haga lo siguiente:

a. Elija Condition (Condición).


b. Especifique el nombre de atributo, el operador de comparación, el tipo de atributo y el valor de
atributo.
c. Si se necesitan otras condiciones, seleccione Condition (Condición) de nuevo.

Para obtener más información, consulte Expresiones de condición (p. 428).

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

Versión de API 2012-08-10


875
Amazon DynamoDB Guía para desarrolladores
Generación de operaciones

Query
Para ejecutar o generar código para unQuery, realice una de las siguientes opciones.

1. Especifique el valor de la clave de partición.


2. Si se necesita una clave de clasificación para la operación Query:

a. Seleccione Sort key (Clave de ordenación).


b. Especifique el operador de comparación, el tipo de atributo y el valor de atributo.
3. Si no se deben devolver todos los atributos con el resultado de la operación, seleccione Projection
expression (Expresión de proyección).
4. Elija + (signo más).
5. Escriba el atributo que se devolverá con el resultado de la consulta.
6. Si se necesitan más atributos, seleccione +.
7. Si debe satisfacerse una expresión de condición para que la operación Query se realice
correctamente, haga lo siguiente:

a. Elija Condition (Condición).


b. Especifique el nombre de atributo, el operador de comparación, el tipo de atributo y el valor de
atributo.
c. Si se necesitan otras condiciones, seleccione Condition (Condición) de nuevo.

Para obtener más información, consulte Expresiones de condición (p. 428).

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

Versión de API 2012-08-10


876
Amazon DynamoDB Guía para desarrolladores
Generación de operaciones

2. Elija + (signo más).


3. Especifique el atributo que se devolverá con el resultado de la consulta.
4. Si se necesitan más atributos, vuelva a seleccionar +.
5. Si debe satisfacerse una expresión de condición para que la operación de examen se realice
correctamente, haga lo siguiente:

a. Elija Condition (Condición).


b. Especifique el nombre de atributo, el operador de comparación, el tipo de atributo y el valor de
atributo.
c. Si se necesitan otras condiciones, seleccione Condition (Condición) de nuevo.

Para obtener más información, consulte Expresiones de condición (p. 428).


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

1. Elija + (signo más).


2. Siga las instrucciones para laRecibir artículo (p. 872).

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.

Versión de API 2012-08-10


877
Amazon DynamoDB Guía para desarrolladores
Generación de operaciones

TransactWriteItems
Para ejecutar o generar código para unTransactWriteItems, realice una de las siguientes opciones.

1. En el menú desplegable Actions (Acciones), elija la operación que desee.

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

Cuando termine de especificar los detalles de la operación, elija el botón +.

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

Versión de API 2012-08-10


878
Amazon DynamoDB Guía para desarrolladores
Modelos de datos de ejemplo

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

Modelos de datos de ejemplo para NoSQL


Workbench
La página principal del modelador y el visualizador muestran una serie de modelos de ejemplo que se
incluyen con NoSQL Workbench. En esta sección se describen estos modelos y sus usos potenciales.

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)

Versión de API 2012-08-10


879
Amazon DynamoDB Guía para desarrolladores
Modelo de datos de empleados

Modelo de datos de empleados


Este modelo de datos es un modelo introductorio. Representa los detalles básicos de un empleado, como
un alias único, nombre, apellido, designación, gerente y habilidades.

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.

Los patrones de acceso que este modelo de datos facilita son:

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

Modelo de datos del foro de debate


Este modelo de datos representa un foro de debate. Los clientes pueden interaccionar con la comunidad
de desarrolladores, plantear preguntas y contestar a las publicaciones de otros clientes. EachAWStiene
un foro específico. Cualquier persona puede iniciar un nuevo hilo de debate publicando un mensaje en un
foro, y cada hilo recibe un cierto número de respuestas.

Los patrones de acceso que este modelo de datos facilita son:

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

Modelo de datos de biblioteca de música


Este modelo de datos representa una biblioteca de música que tiene una gran colección de canciones y
muestra sus canciones más descargadas casi en tiempo real.

Los patrones de acceso que este modelo de datos facilita son:

• Recuperación de un disco de canción, facilitada por una tabla llamada Songs.


• Recuperación de un registro de descarga específico o todos los registros de descarga de una canción,
facilitada por una tabla llamada Songs.
• Recuperación de un registro de recuento mensual específico de descargas o todos los registros de
recuento de descargas mensuales de una canción, facilitada por una tabla llamada Song.
• Recuperación de todos los registros (incluidos los registros de canciones, los registros de descargas
y los registros de recuento de descargas mensuales) de una canción, facilitada por una tabla llamada
Songs.
• Buscar la mayoría de las canciones descargadas, facilitado por el índice secundario global de la tabla
Canciones llamado DownloadsByMonth.

Versión de API 2012-08-10


880
Amazon DynamoDB Guía para desarrolladores
Modelo de datos de estación de esquí

Modelo de datos de estación de esquí


Este modelo de datos representa una estación de esquí que tiene una gran colección de datos para cada
telesilla recogidos diariamente.

Los patrones de acceso que este modelo de datos facilita son:

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

Modelo de datos de ofertas de tarjetas de crédito


Este modelo de datos es utilizado por una aplicación de ofertas de tarjetas de crédito.

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.

Los patrones de acceso que este modelo de datos facilita son:

• Recuperación de registros de cuenta usandoAccountId, según lo facilitado en la tabla principal.


• Recuperación de todas las cuentas con pocos elementos previstos, facilitada por el índice secundario
AccountIndex.
• Recuperación de cuentas y todos los registros de oferta asociados con esas cuentas mediante el uso de
AccountId, facilitado por la tabla principal.
• Recuperación de cuentas y registros de ofertas específicas asociadas con esas cuentas mediante el uso
de AccountId y OfferId, según lo facilitado en la tabla principal.
• Recuperación de todos los registros de oferta ACCEPTED/DECLINED de OfferType específicos
asociados con cuentas usando AccountId, OfferType, y Status, según lo facilitado por el índice
secundario GSI1.
• Recuperación de ofertas y registros de elementos de oferta asociados utilizando OfferId, según lo
facilitado en la tabla principal.

Modelo de datos de marcadores


Este modelo de datos se utiliza marcadores de tienda para los clientes.

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.

Los patrones de acceso que este modelo de datos facilita son:

• Una sola consulta de customerId ahora puede devolver datos de clientes, así como marcadores.

Versión de API 2012-08-10


881
Amazon DynamoDB Guía para desarrolladores
Historial de versiones

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

Historial de versiones de NoSQL Workbench


En la tabla siguiente se describen los cambios importantes en cada versión de la herramienta cliente de
NoSQL Workbench.

Cambio Descripción Fecha

Configuración de capacidad NoSQL Workbench para 21 de abril de 2021


e importación/exportación de Amazon DynamoDB ahora
CloudFormation admite la especificación de un
modo de capacidad de lectura/
escritura para tablas, y ahora
puede importar y exportar
modelos de datos enAWS
CloudFormationformato.

Support con PartiQL NoSQL Workbench para Amazon 4 de diciembre de 2020


DynamoDB ahora admite la
creación de sentencias PartiQL
para DynamoDB.

Support con Linux. NoSQL Workbench para Amazon 4 de mayo de 2020


DynamoDB es compatible con
Linux, Ubuntu, Fedora y Debian.

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.

Compatibilidad para DynamoDB NoSQL Workbench ahora 8 de noviembre de 2019


Local (versión descargable). admite conectarse a DynamoDB
Local (versión descargable)
para diseñar, crear, consultar y
administrar tablas de DynamoDB.

Publicación de la vista previa de Es la versión inicial de NoSQL 16 de septiembre de 2019


NoSQL Workbench. Workbench para DynamoDB.
Utilice NoSQL Workbench
para diseñar, crear, consultar y
administrar tablas de DynamoDB.
Para obtener más información,
consulte NoSQL Workbench
para Amazon DynamoDB (vista
previa).

Versión de API 2012-08-10


882
Amazon DynamoDB Guía para desarrolladores
Protección de los datos

Seguridad y conformidad en Amazon


DynamoDB
La seguridad en la nube de AWS es la mayor prioridad. Como cliente de AWS, se beneficiará de una
arquitectura de red y un centro de datos diseñados para satisfacer los requisitos de seguridad de las
organizaciones más exigentes.

La seguridad es una responsabilidad compartida entre AWS y usted. El modelo de responsabilidad


compartida la describe como seguridad de la nube y seguridad en la nube:

• Seguridad de la nube–AWSes responsable de proteger la infraestructura que ejecutaAWSen laAWSUna


nube de.AWStambién le proporciona servicios que puede utilizar de forma segura. Auditores externos
prueban y verifican periódicamente la eficacia de nuestra seguridad en el marco de los programas de
conformidad de AWS. Para obtener más información acerca de los programas de conformidad que se
aplican a DynamoDB, consulteAWSServicios en el ámbito del programa de conformidad.
• Seguridad en la nube— Su responsabilidad está determinada por elAWSque utilice. Usted también es
responsable de otros factores incluida la confidencialidad de los datos, los requisitos de la empresa y la
legislación y los reglamentos aplicables.

Esta documentación le ayudará a comprender cómo aplicar el modelo de responsabilidad compartida


cuando se utiliza DynamoDB. En los siguientes temas, aprenderá a configurar DynamoDB para satisfacer
sus objetivos de seguridad y conformidad. También aprenderá a utilizar otrosAWSServicios de que le
ayudan a monitorizar y proteger sus recursos de DynamoDB.

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)

Protección de datos en DynamoDB


Amazon DynamoDB proporciona una infraestructura de almacenamiento de alta durabilidad diseñada para
el almacenamiento de datos principales y críticos. Los datos se almacenan de forma redundante en varios
dispositivos de diversas instalaciones dentro de una región de Amazon DynamoDB.

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)

Versión de API 2012-08-10


883
Amazon DynamoDB Guía para desarrolladores
Cifrado en reposo

• Privacidad del tráfico entre redes (p. 893)

DynamoDB ado en reposo


Todos los datos de usuario almacenados en Amazon DynamoDB están completamente cifrados en
reposo. El cifrado en reposo de DynamoDB proporciona mayor seguridad al cifrar todos los datos en
reposo mediante las claves de cifrado almacenadas enAWS Key Management Service(AWS KMS).
Esta funcionalidad ayuda a reducir la carga y la complejidad operativas que conlleva la protección de
información confidencial. Con el cifrado en reposo, puede crear aplicaciones sensibles a la seguridad que
necesitan cumplimiento estricto de cifrado y requisitos normativos.

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.

El cifrado de DynamoDB en reposo está disponible en todos losAWSRegiones, incluida laAWSChina


(Pekín) yAWSRegión China (Ningxia) yAWSRegiones GovCloud (US). Para obtener más información,
consulte Cifrado en reposo: Cómo funciona (p. 885) y Notas de uso de DynamoDB en reposo (p. 886).

Versión de API 2012-08-10


884
Amazon DynamoDB Guía para desarrolladores
Cifrado en reposo

Cifrado en reposo: Cómo funciona


El cifrado en reposo de Amazon DynamoDB cifra los datos mediante el estándar de cifrado avanzado
de 256 bits (AES-256), que ayuda a proteger los datos del acceso no autorizado al almacenamiento
subyacente.

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.

AWSCMK administrada por


AWSLas CMK administradas por son las CMK de la cuenta que se crean, administran y usan en nombre
de unaAWSque está integrado conAWS KMS. Puede ver las CMK administradas por AWS en su cuenta,
ver sus políticas de claves y auditar su uso en los registros de AWS CloudTrail. Sin embargo, no puede
administrar estas CMK ni modificar sus permisos.

El cifrado en reposo se integra automáticamente conAWS KMSpara administrarAWSCMK administrada


por DynamoDB (aws/dynamodb) que se utiliza para cifrar las tablas de. Si unAWSCMK administrado no
existe cuando crea la tabla de DynamoDB cifrada,AWS KMScrea automáticamente una nueva clave para
usted. Esta clave se utiliza con tablas cifradas que se crean en el futuro.AWS KMScombina hardware y
software seguros de alta disponibilidad para ofrecer un sistema de administración de claves adaptado a la
nube.

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.

CMK administrada por el cliente


Los CMK administrados por el cliente son CMK en suAWSLa cuenta que crea, posee y administra.
Puede controlar por completo estas CMK, incluido el establecimiento y el mantenimiento de sus políticas
de claves, políticas de IAM y concesiones; su habilitación y deshabilitación; la rotación de su material
criptográfico; la adición de etiquetas; la creación de alias que hacen referencia a ellas y la programación

Versión de API 2012-08-10


885
Amazon DynamoDB Guía para desarrolladores
Cifrado en reposo

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.

Si deshabilita su CMK administrada por el cliente o la programa para su eliminación, su estado de la


tabla se convierte enInaccesible. Para asegurarse de que puede continuar trabajando con la tabla, debe
proporcionar acceso a DynamoDB a la clave de cifrado especificada en un plazo de siete días. Tan pronto
como el servicio detecte que la clave de cifrado es inaccesible, DynamoDB le envía una notificación por
correo electrónico para avisarle.
Note
• Si su CMK administrado por el cliente permanece inaccesible para el servicio DynamoDB
durante más de siete días, la tabla se archiva y ya no se puede acceder a ella. DynamoDB
crea una copia de seguridad bajo demanda de la tabla y se le cobra. Puede utilizar esta
copia de seguridad bajo demanda para restaurar los datos en una nueva tabla. Para iniciar
la restauración, la última CMK administrada por el cliente en la tabla debe estar habilitada y
DynamoDB debe tener acceso a ella.
• Si el CMK administrado por el cliente que se utilizó para cifrar una réplica de tabla global 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 detectar el CMK
administrado por el cliente como inaccesible.

Notas sobre el uso de CMK administrados


Amazon DynamoDB no puede leer los datos de la tabla a menos que tenga acceso al CMK almacenado
en suAWS KMSaccount. DynamoDB utiliza el cifrado de envolvente y la jerarquía de claves para cifrar
los datos. SusAWS KMSclave de cifrado se utiliza para cifrar la clave raíz de esta jerarquía de claves.
Para obtener más información, consulteCifrado de sobreen laAWS Key Management ServiceGuía para
desarrolladores.

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.

Notas de uso de DynamoDB en reposo


Tenga en cuenta lo siguiente cuando use el cifrado en reposo en Amazon DynamoDB.

Versión de API 2012-08-10


886
Amazon DynamoDB Guía para desarrolladores
Cifrado en reposo

Todos los datos de la tabla se cifran


El cifrado en reposo en el lado del servidor está habilitado para todos los datos de la tabla de DynamoDB
y no se puede deshabilitar. No se puede cifrar sólo un subconjunto de elementos de una tabla. DynamoDB
ha cifrado todas las tablas existentes que se habían descifrado previamente mediante elAWSCMK
propiedad de el cliente (CMK).

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.

Versión de API 2012-08-10


887
Amazon DynamoDB Guía para desarrolladores
Cifrado en reposo

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

Administración de tablas de cifrado en DynamoDB


Puede utilizar laAWS Management Consoleo elAWS Command Line Interface(AWS CLI) para especificar
la clave de cifrado en las tablas nuevas y actualizar las claves de cifrado en las tablas existentes en
Amazon DynamoDB.

Temas
• Especificación de la clave de cifrado para una tabla nueva (p. 888)
• Configuración de una clave de cifrado (p. 890)

Especificación de la clave de cifrado para una tabla nueva


Siga estos pasos para especificar la clave de cifrado en una tabla nueva mediante la consola de Amazon
DynamoDB o laAWS CLI.

Creación de una tabla cifrada (consola)

1. Inicie sesión enAWS Management Consoley abra la consola de DynamoDB enhttps://


console.aws.amazon.com/dynamodb/.
2. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas).
3. Seleccione Create Table (Crear tabla). En Table name (Nombre de la tabla), escriba Music. Como
clave principal, introduzca Artist y como clave de ordenación, introduzca SongTitle, ambas como
cadenas.
4. En la sección Table settings (Configuración de la tabla), asegúrese de que la opción Use default
settings (Usar configuración predeterminada) no esté seleccionada.

Note

SiUtilización de la configuración predeterminada, las tablas se cifran en reposo con la


opciónAWSLa clave maestra del cliente propiedad (CMK) sin cargo adicional.
5. En Encryption at rest (Cifrado en reposo), elija un tipo de cifrado:

• Valor predeterminado–AWSCMK propiedad de. La clave es propiedad de DynamoDB (sin cargo


adicional).
• KMSCMK administrada por el cliente. La clave se almacena en su cuenta y usted la crea, posee y
administra (se aplican cargos de AWS KMS).
• KMS–AWSCMK administrada por. La clave se almacena en su cuenta y la administra AWS Key
Management Service. (Se aplican los cargos de AWS KMS).

Versión de API 2012-08-10


888
Amazon DynamoDB Guía para desarrolladores
Cifrado en reposo

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

Creación de una tabla cifrada (AWS CLI)

UsarAWS CLIpara crear una tabla con el valor predeterminadoAWSCMK propiedad de,AWSo un CMK
administrado por el cliente para Amazon DynamoDB.

Para crear una tabla cifrada mediante laAWSCMK propiedad de

• Cree la tabla cifrada Music como sigue:

aws dynamodb create-table \


--table-name Music \
--attribute-definitions \
AttributeName=Artist,AttributeType=S \
AttributeName=SongTitle,AttributeType=S \
--key-schema \
AttributeName=Artist,KeyType=HASH \
AttributeName=SongTitle,KeyType=RANGE \
--provisioned-throughput \
ReadCapacityUnits=10,WriteCapacityUnits=5

Note

La tabla ha quedado cifrada mediante laAWSCMK propiedad en la cuenta de servicio de


DynamoDB.

Para crear una tabla cifrada mediante laAWSCMK administrada por DynamoDB

• Cree la tabla cifrada Music como sigue:

aws dynamodb create-table \


--table-name Music \
--attribute-definitions \

Versión de API 2012-08-10


889
Amazon DynamoDB Guía para desarrolladores
Cifrado en reposo

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

El estado SSEDescription de la descripción de la tabla se establece en ENABLED y SSEType es


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

• Cree la tabla cifrada Music como sigue:

aws dynamodb create-table \


--table-name Music \
--attribute-definitions \
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,KMSMasterKeyId=abcd1234-abcd-1234-a123-
ab1234a1b234

El estado SSEDescription de la descripción de la tabla se establece en ENABLED y SSEType es


KMS.

"SSEDescription": {
"SSEType": "KMS",
"Status": "ENABLED",
"KMSMasterKeyArn": "arn:aws:kms:us-east-1:123456789012:key/abcd1234-abcd-1234-a123-
ab1234a1b234",
}

Configuración de una clave de cifrado


También puede usar la consola de DynamoDB o laAWS CLIpara actualizar las claves de cifrado de una
tabla existente entreAWSCMK propiedad de,AWSCMK administrada por el cliente en cualquier momento.

Actualización de una clave de cifrado (consola)

1. Inicie sesión enAWS Management Consoley abra la consola de DynamoDB enhttps://


console.aws.amazon.com/dynamodb/.
2. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas).

Versión de API 2012-08-10


890
Amazon DynamoDB Guía para desarrolladores
Cifrado en reposo

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

5. Elija un tipo de cifrado.

• Valor predeterminado–AWSCMK propiedad de. La clave es propiedad de DynamoDB (sin cargo


adicional).
• KMSCMK administrada por el cliente. La clave se almacena en su cuenta y usted la crea, posee y
administra (se aplican cargos de AWS KMS).
• KMS–AWSCMK administrada por. La clave se almacena en su cuenta y la administra AWS Key
Management Service. (Se aplican los cargos de AWS KMS).

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

Actualización de una clave de cifrado (AWS CLI)


Los siguientes ejemplos muestran cómo actualizar una tabla cifrada con la AWS CLI.

Versión de API 2012-08-10


891
Amazon DynamoDB Guía para desarrolladores
Cifrado en reposo

Para actualizar una tabla cifrada mediante laAWSCMK propiedad de

• Actualice la tabla cifrada Music, como en el siguiente ejemplo.

aws dynamodb update-table \


--table-name Music \
--sse-specification Enabled=false

Note

La tabla ha quedado cifrada mediante laAWSCMK propiedad en la cuenta de servicio de


DynamoDB.

Para actualizar una tabla cifrada mediante laAWSCMK administrada por DynamoDB

• Actualice la tabla cifrada Music, como en el siguiente ejemplo.

aws dynamodb update-table \


--table-name Music \
--sse-specification Enabled=true

El estado SSEDescription de la descripción de la tabla se establece en ENABLED y SSEType es


KMS.

"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

• Actualice la tabla cifrada Music, como en el siguiente ejemplo.

aws dynamodb update-table \


--table-name Music \
--sse-specification Enabled=true,SSEType=KMS,KMSMasterKeyId=abcd1234-abcd-1234-a123-
ab1234a1b234

El estado SSEDescription de la descripción de la tabla se establece en ENABLED y SSEType es


KMS.

"SSEDescription": {
"SSEType": "KMS",
"Status": "ENABLED",
"KMSMasterKeyArn": "arn:aws:kms:us-east-1:123456789012:key/abcd1234-abcd-1234-a123-
ab1234a1b234",
}

Versión de API 2012-08-10


892
Amazon DynamoDB Guía para desarrolladores
Protección de datos en DAX

Protección de datos en DynamoDB Accelerator


El cifrado en reposo de Amazon DynamoDB Accelerator (DAX) proporciona una capa adicional de
protección de datos al ayudarle a proteger los datos del acceso no autorizado al almacenamiento
subyacente. Las políticas de la organización, las normativas industriales o gubernamentales y los
requisitos de conformidad pueden requerir el uso del cifrado en reposo para proteger los datos. Puede
utilizar el cifrado para aumentar la seguridad de datos de las aplicaciones implementadas en la nube.

Para obtener más información acerca de la protección de datos en DAX, consulteCifrado DAX en
reposo (p. 825).

Privacidad del tráfico entre redes


Las conexiones están protegidas entre Amazon DynamoDB y las aplicaciones locales y entre DynamoDB y
DynamoDB y otrasAWSrecursos dentro de la mismaAWSRegión .

Tráfico entre el servicio y aplicaciones y clientes locales


Tiene dos opciones de conectividad entre su red privada y AWS:

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

Tráfico entre recursos de AWS en la misma región


Un punto de enlace de Amazon Virtual Private Cloud (Amazon VPC) para DynamoDB es una entidad
lógica dentro de una VPC que permite la conectividad solo a DynamoDB. La VPC de Amazon direcciona
las solicitudes a DynamoDB y vuelve a direccionar las respuestas a la VPC. Para obtener más información,
consulte Puntos de enlace de la VPC en la Guía del usuario de Amazon VPC. Para consultar ejemplos de
políticas que puede utilizar para controlar el acceso desde los puntos de enlace de la VPC, consulteUso de
políticas de IAM para controlar el acceso a DynamoDB.

Identity and Access Management


Los administradores de IAM controlan quién puede estar autenticado (iniciar sesión) y autorizado
(tiene permisos) para utilizar recursos de Amazon DynamoDB. Puede usarAWS Identity and Access
Management(IAM) para administrar los permisos de acceso e implementar políticas de seguridad para
Amazon DynamoDB y DynamoDB Accelerator (DAX).

Temas
• Identity and Access Management (p. 894)

Versión de API 2012-08-10


893
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

• Identity and Access Management (p. 925)

Identity and Access Management


El acceso a Amazon DynamoDB requiere credenciales de. Estas credenciales deben tener permisos para
obtener acceso aAWSRecursos de, como una tabla de Amazon DynamoDB o una instancia de Amazon
Elastic Compute Cloud (Amazon EC2). En las siguientes secciones presentamos más detalles sobre
cómo usarAWS Identity and Access Management(IAM)DynamoDB para ayudar a proteger el acceso a los
recursos de.

• Authentication (p. 894)


• Control de acceso (p. 895)

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.

Versión de API 2012-08-10


894
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

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

• Información general sobre la administración de acceso (p. 895)


• Uso de políticas basadas en identidad (políticas de IAM) (p. 898)
• Referencia de permisos de la API de Dynamo (p. 908)
• Uso de condiciones (p. 909)

Información general sobre la administración de permisos de


acceso a sus recursos de Amazon DynamoDB
Cada recurso de AWS es propiedad de una cuenta de AWS, y los permisos para crear o tener acceso a
un recurso se rigen por las políticas de permisos. Los administradores de cuentas pueden asociar políticas
de permisos a identidades de IAM (es decir, usuarios, grupos y funciones). Algunos servicios (como AWS
Lambda) también permiten asociar políticas de permisos con los recursos.
Note

Un administrador de la cuenta (o usuario administrador) es un usuario con privilegios de


administrador. Para obtener más información, consulte Prácticas recomendadas de IAM en la
Guía del usuario de IAM.

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)

Versión de API 2012-08-10


895
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

Recursos y operaciones de DynamoDB

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:

Tipo de recurso Formato de ARN

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.

Titularidad de los recursos


La cuenta de AWS es la propietaria de los recursos que se crean en ella, independientemente de
quién los haya creado. En concreto, el propietario del recurso es elAWSde laentidad principal(es decir,
elAWSUsuario raíz de la cuenta, un usuario de IAM o un rol de IAM) que autentica la solicitud de creación
de recursos. Los siguientes ejemplos ilustran cómo funciona:

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

Administración del acceso a los recursos


Una política de permisos describe quién tiene acceso a qué. En la siguiente sección se explican las
opciones disponibles para crear políticas de permisos.
Note

En esta sección se explica cómo se usa IAM en el contexto de DynamoDB. No se proporciona


información detallada sobre el servicio de IAM. Para obtener la documentación completa de IAM,
consulte¿Qué es IAM?en laGuía del usuario de IAM. 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.

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

Versión de API 2012-08-10


896
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

• Políticas basadas en identidad (políticas de IAM) (p. 897)


• Políticas basadas en recursos (p. 897)

Políticas basadas en identidad (políticas de IAM)

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.

Políticas basadas en recursos

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.

Versión de API 2012-08-10


897
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

Especificación de elementos de política: Acciones, efectos y entidades principales


Para cada recurso de DynamoDB, el servicio define un conjunto de operaciones de API. Para conceder
permisos a estas operaciones de la API, DynamoDB define un conjunto de acciones que puede especificar
en una política. Algunas operaciones de API pueden requerir permisos para más de una acción para poder
realizar la operación de API. Para obtener más información sobre los recursos y las operaciones de API,
consulteRecursos y operaciones de DynamoDB (p. 896)y DynamoDBActions.

A continuación se indican los elementos más básicos de la política:

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

Especificación de las condiciones de una política


Al conceder permisos, puede utilizar el lenguaje de la política de acceso para especificar las condiciones
en las que se debe aplicar una política. Por ejemplo, es posible que desee que solo se aplique una política
después de una fecha específica. Para obtener más información sobre cómo especificar condiciones en un
lenguaje de política, consulte Condition en la Guía del usuario de IAM.

Para expresar condiciones, se usan claves de condición predefinidas. HayAWSTeclas de condición


generales y claves específicas de DynamoDB que puede utilizar cuando corresponda. Para obtener una
lista completa deAWSteclas anchas, consulteClaves disponibles de condicionesen laGuía del usuario de
IAM. Para obtener una lista completa de las claves específicas de DynamoDB, consulteUso de condiciones
de políticas de IAM para control de acceso preciso (p. 909).

Uso de políticas basadas en identidad (políticas de IAM) con


Amazon DynamoDB
EsteTema deFundas de usoBasados en identidadesAWS Identity and Access Management(IAM)
con Amazon DynamoDBy proporciona ejemplos. Ejemplos showCómo un administrador de cuentas
puede asociar políticas de permisos a identidades de IAM (es decir, usuarios, grupos y roles)y por lo
tantoconceden permisos para realizar operaciones en recursos de Amazon DynamoDB.
Important

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

Versión de API 2012-08-10


898
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

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

En las secciones de este tema se explica lo siguiente:

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

A continuación se muestra un ejemplo de una política de permisos.

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

Permisos de IAM necesarios para utilizar la consola de Amazon DynamoDB


Para trabajar con la consola de DynamoDB, un usuario debe tener un conjunto mínimo de permisos que
le permitan trabajar con suAWSrecursos de DynamoDB de la cuenta. Además de estos permisos de
DynamoDB, la consola requiere permisos:

• Permisos de Amazon CloudWatch para mostrar las métricas y los gráficos.


• AWS Data PipelinePermisos de para exportar e importar datos de DynamoDB.
• Permisos de AWS Identity and Access Management para obtener acceso a los roles necesarios para
importar y exportar.
• Permisos de Amazon Simple Notification Service para recibir notificaciones cada vez que se active una
alarma de CloudWatch.
• AWS LambdaPermisos de para procesar registros de DynamoDB Streams de.

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.

Versión de API 2012-08-10


899
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

AWSPolíticas de IAM administradas (predefinidas) por Amazon DynamoDB


AWSaborda algunos casos de uso comunes proporcionando políticas de IAM independientes creadas y
administradas porAWS. EstosAWSEstas políticas administradas de conceden los permisos necesarios
para casos de uso comunes, lo que le evita tener que investigar los permisos que se necesitan. Para
obtener más información, consulteAWSPolíticas administradas deen laGuía del usuario de IAM.

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:

• AmazonDynamoDBReadOnlyAccess: concede acceso de solo lectura a los recursos de DynamoDBA


través deelAWS Management Console.
• AmazonDynamoDBFullAccess: concede acceso completo a los recursos de DynamoDBA través
deelAWS Management Console.

Puede revisar estosAWSInicie sesión en la consola de IAM y busque las políticas específicas.
Important

La práctica recomendada es crear políticas de IAM personalizadas que otorguenLEAST privilegeA


los usuarios, roles o grupos de IAM que los requieran.

Ejemplos de políticas administradas por el cliente


En esta sección, encontrará ejemplos de políticas que conceden permisos para diversas acciones de
DynamoDB. Estas políticas funcionan cuando utilizaAWSSDK de oAWS CLI. Cuando utiliza la consola
de, debe conceder permisos adicionalesque sonespecífico de la consola. Para obtener más información,
consulte Permisos de IAM necesarios para utilizar la consola de Amazon DynamoDB (p. 899).
Note

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)

LaGuía del usuario de IAM, incluye tres ejemplos adicionales de DynamoDB:

• Amazon DynamoDB: : permite el acceso a una determinada tabla


• Amazon DynamoDB: : permite el acceso a columnas determinadas
• Amazon DynamoDB: Permite el acceso de nivel de fila a DynamoDB en función de un ID de Amazon
Cognito

Versión de API 2012-08-10


900
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

Política de IAM para conceder permisos a todas las acciones de DynamoDB en


una tabla
La política de siguiente concede permisos paraTodoAcciones de DynamoDB en una tabla llamadaBooks.
El ARN de recurso especificado en elResourceIdentifica una tabla en un campo específicoAWSRegión .
Si reemplaza el nombre de la tablaBooksen laResourceARN con carácter comodín (*),TodoLas acciones
de DynamoDB están permitidas enTodoen la cuenta. Considere detenidamente las posibles implicaciones
de seguridad antes de utilizar un carácter comodín en esta directiva o en cualquier otra de IAM.

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

Versión de API 2012-08-10


901
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

{
"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",

Versión de API 2012-08-10


902
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

"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/*"
]

Política de IAM para separar entornos de DynamoDB en el mismoAWSCuenta


Supongamos que tiene entornos independientes, de tal forma que cada uno de ellos mantiene su
propia versión de una tabla denominadaProductCatalog. Si crea dosProductCatalogtablas en el
mismoAWSEl trabajo en un entorno podría afectar al otro entorno debido al modo en que se configuran
los permisos. Por ejemplo, las cuotas en el número de operaciones simultáneas del plano de control
(comoCreateTable) se establecen en elAWSnivel de cuenta.

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",

Versión de API 2012-08-10


903
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

"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",

Versión de API 2012-08-10


904
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

"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

Cuando utiliza variables de políticas de IAM, debe especificar explícitamente la


propiedad2012-10-17versión delIAMlenguaje de la políticaen la política. La versión
predeterminada deIAMlenguaje de la política(2008-10-17) no admite variables de política.

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}_*"

Política de IAM para evitar la compra de capacidad reservada de DynamoDB


Con la capacidad reservada de Amazon DynamoDB, se abona una tarifa inicial única y se adquiere el
compromiso de abonar un nivel de uso mínimo con un ahorro significativo durante un periodo concreto.
Puede utilizar la AWS Management Console para consultar y adquirir capacidad reservada. Sin embargo,
puede que no sea conveniente que todos los usuarios de la organización puedan adquirir capacidad
reservada. Para obtener más información acerca de la capacidad reservada, consulte.Precios de Amazon
DynamoDB.

DynamoDB ofrece las siguientes operaciones de API para controlar el acceso a la administración de la
capacidad reservada:

• dynamodb:DescribeReservedCapacity: devuelve las adquisiciones de capacidad reservada que se


encuentran en vigor.
• dynamodb:DescribeReservedCapacityOfferings: devuelve detalles sobre los planes de
capacidad reservada que se ofrecen en ese momento porAWS.
• dynamodb:PurchaseReservedCapacityOfferings: lleva a cabo la adquisición propiamente dicha
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

Versión de API 2012-08-10


905
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

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.

Política de IAM para conceder acceso de lectura para una secuencia de


DynamoDB solamente (no para la tabla)
Al habilitar las DynamoDB Streams en una tabla, se obtiene información sobre cada modificación de
los elementos de esa tabla. Para obtener más información, consulte Captura de datos de cambio para
DynamoDB Streams (p. 661).

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": [

Versión de API 2012-08-10


906
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

{
"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í.

Directiva de IAM para permitir unaAWS LambdaFunción para acceder a registros


de flujo de DynamoDB
Si desea llevar a acabo determinadas acciones basándose en los eventos de una secuencia de
DynamoDB, puede escribir unAWS LambdaEstos eventos activan. Una función Lambda requiere
permisos para leer los datos de una secuencia de DynamoDB. Para obtener más información
acerca del uso de Lambda con DynamoDB Streams, consultey DynamoDB StreamsAWS
LambdaDesencadenadores (p. 681).

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.

Versión de API 2012-08-10


907
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

Directiva de IAM para el acceso de lectura y escritura a un clúster de DynamoDB


Accelerator (DAX)
La siguiente políticapermite leer, escribir, actualizar y eliminar el acceso a unAccelerador
DynamoDB(DAX), pero no a la tabla de DynamoDB asociada. Para utilizar esta directiva, sustituya
elAWSNombre de la región, el ID de su cuenta y el nombre de suDAXclústerclúster.
Note

Esta política otorga acceso aclústerclúster de DAX, pero no a laAsociadosTabla de DynamoDB.


Asegúrese de quethatsu clúster DAX tiene la directiva correcta para realizar estas mismas
operaciones en la tabla de DynamoDB en su nombre.

{
"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"

: permisos de la API DynamoDB Referencia de acciones,


recursos y condiciones
Cuando está configurandoControl de acceso (p. 895)Y escribiendo una política de permisos que se
pueda asociar a una identidad de IAM (políticas basadas en identidad), puede utilizar la lista deClaves
de condición, recursos y acciones de Amazon DynamoDBen laGuía del usuario de IAMcomo referencia.
En la página figuran las operaciones de las API de DynamoDB, las acciones correspondientes a las que
puede conceder permisos para realizar la acción y lasAWSPara el que puede conceder los permisos. Las
acciones se especifican en el campo Action de la política y el valor del recurso se especifica en el campo
Resource de la política.

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

Versión de API 2012-08-10


908
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

Temas relacionados
• Control de acceso (p. 895)
• Uso de condiciones de políticas de IAM para control de acceso preciso (p. 909)

Uso de condiciones de políticas de IAM para control de acceso


preciso
Al conceder permisos en DynamoDB, puede especificar condiciones que determinan cómo se aplica una
política de permisos.

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

AlgunoAWSLos servicios de también admiten las condiciones basados en etiquetas, pero


DynamoDB no las admite.

Caso de uso de permisos


Además de controlar el acceso a acciones del API de DynamoDB, puede controlar el acceso a elementos y
atributos de datos individuales. Por ejemplo, puede hacer lo siguiente:

• 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

Versión de API 2012-08-10


909
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

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": [

Versión de API 2012-08-10


910
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

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

Además de conceder permisos para acciones específicas de DynamoDB (Actionelemento) en


elGameScoresTabla deResource), el elementoConditionEl componente utiliza las claves de condición
siguientes específicas de DynamoDB que limitan los permisos como se indica a continuación:

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

Versión de API 2012-08-10


911
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

Especificación de condiciones: Uso de claves de condición


AWSproporciona un conjunto de claves de condiciones predefinidos (AWSClaves de condición generales)
para todosAWSque admiten IAM para el control de acceso. Por ejemplo, puede usar la clave de condición
aws:SourceIp para comprobar la dirección IP del solicitante antes de permitir que se lleve a cabo
cualquier acción. Para obtener más información y una lista de losAWSteclas anchas, consulteClaves
disponibles de condicionesen la guía del usuario de IAM.

En la siguiente tabla se muestran las claves de condición específicas del servicio DynamoDB que se
aplican a DynamoDB.

Clave de condición Descripción


DynamoDB

dynamodb:LeadingKeysRepresenta el primer atributo de clave de una tabla; es decir, la clave de


partición. El nombre de la clave, LeadingKeys, es plural, aunque la clave
se utiliza en acciones que afectan a un solo elemento. Además, debe usar el
modificador ForAllValues cuando utilice LeadingKeys en una condición.

dynamodb:Select Representa el parámetro Select de una solicitud Query o Scan. Select


puede ser cualquiera de los valores siguientes:

• 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

Se usa en: BatchGetItem, GetItem, Query, Scan


• AttributeUpdates

Se usa en: UpdateItem


• Expected

Se usa en: DeleteItem, PutItem, UpdateItem


• Item

Se usa en: PutItem


• ScanFilter

Se usa en: Scan

Representa el parámetro ReturnValues de una solicitud. ReturnValues


dynamodb:ReturnValues
puede ser cualquiera de los valores siguientes:

• ALL_OLD
• UPDATED_OLD
• ALL_NEW
• UPDATED_NEW

Versión de API 2012-08-10


912
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

Clave de condición Descripción


DynamoDB
• NONE

Representa el parámetro ReturnConsumedCapacity de una solicitud.


dynamodb:ReturnConsumedCapacity
ReturnConsumedCapacity puede ser uno de los valores siguientes:

• TOTAL
• NONE

Limitación del acceso de los usuarios

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.

Ejemplos de políticas: Uso de condiciones para control de acceso detallado

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.

Versión de API 2012-08-10


913
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

{
"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}"
]
}
}
}
]
}

Versión de API 2012-08-10


914
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

Important

Si usadynamodb:AttributesEn, debe especificar los nombres de todos los atributos de clave


principal y clave de índice, tanto de la tabla como 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.

2: Concesión de permisos que limitan el acceso a determinados atributos de una tabla

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.

Versión de API 2012-08-10


915
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

La cláusula StringEqualsIfExists de la política de permisos se asegura de que se cumpla lo


siguiente:

• Si el usuario especifica el parámetro Select, entonces su valor debe ser SPECIFIC_ATTRIBUTES.


Este requisito se impide que la acción del API devuelva cualquier atributo que no esté permitido; por
ejemplo, desde una proyección de índice.
• Si el usuario especifica el parámetro ReturnValues, entonces su valor debe ser NONE, UPDATED_OLD
o UPDATED_NEW. Esto es obligatorio porque la acción UpdateItem lleva a cabo, además, operaciones
de lectura implícitas para comprobar si un elemento existe antes de sustituirlo y para que los valores de
atributos anteriores se puedan devolver en caso de que se soliciten. Al restringir ReturnValues de este
modo, nos aseguramos de que los usuarios solamente puedan leer o escribir los atributos permitidos.
• La cláusula StringEqualsIfExists se asegura de que solamente se pueda utilizar uno de estos
parámetros (Select o ReturnValues) en cada solicitud, en el contexto de las acciones permitidas.

A continuación se muestran algunas variaciones de esta política:

• Para permitir exclusivamente acciones de lectura, puede eliminar UpdateItem de la lista de


acciones permitidas. Dado que ninguna de las acciones restantes aceptan ReturnValues, puede
eliminar ReturnValues de la condición. Además, puede cambiar StringEqualsIfExists por
StringEquals, porque el parámetro Select siempre tiene un valor (ALL_ATTRIBUTES, a no ser que
se especifique otra cosa).
• Para permitir exclusivamente acciones de escritura, puede eliminar todo excepto UpdateItem de la
lista de acciones permitidas. Dado que UpdateItem no utiliza el parámetro Select, puede eliminar
Select de la condición. Además, debe cambiar StringEqualsIfExists por StringEquals, porque
el parámetro ReturnValues siempre tiene un valor (NONE, a no ser que se especifique otra cosa).
• Para permitir todos los atributos cuyo nombre coincida con un patrón, utilice StringLike en lugar
de StringEquals y use un carácter comodín (*) que halle coincidencias de patrones con varios
caracteres.

3: Permisos de para evitar actualizaciones en determinados atributos

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"

Versión de API 2012-08-10


916
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

]
}
}
}
]
}

Tenga en cuenta lo siguiente:

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

4: Concesión de permisos para consultar únicamente los atributos proyectados de un índice

La siguiente política de permisos permite realizar consultas en un índice secundario


(TopScoreDateTimeIndex) mediante el uso de la funcióndynamodb:AttributesClave de condición.
Además, limita las consultas de tal forma que solo se puedan solicitar determinados atributos que se han
proyectado en el índice.

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

Versión de API 2012-08-10


917
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

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

: 5 Concesión de permisos para limitar el acceso a determinados atributos y valores de clave de


partición

La siguiente directiva de permisos permite acciones específicas de DynamoDB (especificadas


en laActionElemento de) en una tabla y un índice de tabla (que se han especificado en
laResourceElemento). La política utiliza la clave de condición dynamodb:LeadingKeys para restringir
los permisos de tal forma que únicamente incluyan los elementos cuyo valor de clave de partición coincida
con el identificador de Facebook del usuario.

{
"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"
]

Versión de API 2012-08-10


918
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

},
"StringEqualsIfExists": {
"dynamodb:Select": "SPECIFIC_ATTRIBUTES",
"dynamodb:ReturnValues": [
"NONE",
"UPDATED_OLD",
"UPDATED_NEW"
]
}
}
}
]
}

Tenga en cuenta lo siguiente:

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

Uso de identidades web federadas


Cuando escriba una aplicación dirigida a gran cantidad de usuarios, puede utilizar, si lo desea, identidades
web federadas para llevar a cabo las operaciones de autenticación y autorización. Las identidades web
federadas evitan tener que crear usuarios de IAM individuales. En su lugar, los usuarios pueden iniciar
sesión en un proveedor de identidades y obtener credenciales de seguridad temporales de AWS Security
Token Service ( AWS STS ). A continuación, la aplicación puede utilizar estas credenciales para obtener
acceso aAWSServicios de .

Las identidades web federadas admiten los siguientes proveedores de identidad:

• Login with Amazon


• Facebook
• Google

Recursos adicionales para identidades web federadas


Los siguientes recursos pueden ayudarle a obtener más información sobre las identidades web federadas:

• 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

Versión de API 2012-08-10


919
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

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.

Ejemplo de política para identidades web federadas


Para mostrar cómo utilizar las identidades web federadas con DynamoDB, vuelva a visitar
laGameScoresque se introdujo enUso de condiciones de políticas de IAM para control de acceso
preciso (p. 909). Esta es la clave principal para GameScores.

Nombre de la tabla Tipo de clave principal Nombre y tipo de clave Nombre y tipo de clave
de partición de ordenación

GameScores (UserId, Compuesto Nombre de atributo: Nombre de atributo:


GameTitle, ...) UserId GameTitle

Tipo: Cadena Tipo: Cadena

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.

En el diagrama siguiente se muestra cómo se integran estas piezas entre sí.

Versión de API 2012-08-10


920
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

Información general sobre las identidades web federadas

1. La aplicación llama a un proveedor de identidades tercero para autenticar al usuario y la aplicación. El


proveedor de identidades devuelve un token de identidad web a la aplicación.
2. La aplicación llama a AWS STS Y pasa el token de identidad web como información de entrada. AWS
STS autoriza la aplicación y le proporciona temporalAWScredenciales de acceso. La aplicación puede
asumir un rol de IAM (GameRole) y acceda aAWSde acuerdo con la política de seguridad de la función.
3. La aplicación llama a DynamoDB para acceder aGameScoresUna tabla de Dado que la aplicación ha
asumido el rol GameRole, está sujeta a la política de seguridad asociada a ese rol. El documento de
política impide que la aplicación obtenga acceso a datos que no pertenecen al usuario.

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",

Versión de API 2012-08-10


921
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

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

Preparación para usar las identidades web federadas


Si es un desarrollador de aplicaciones y desea utilizar las identidades web federadas para la aplicación,
siga estos pasos:

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.

Versión de API 2012-08-10


922
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

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:

• Cómo autenticar a los usuarios (AWS Mobile SDK for iOS)


• Cómo autenticar a los usuarios (AWS Mobile SDK for Android)

Generación de una directiva de IAM mediante la consola de DynamoDB


La consola de DynamoDB le puede ayudar a crear una política de IAM para utilizarla con las identidades
web federadas. Para ello, se selecciona una tabla de DynamoDB y se especifica el proveedor de
identidades, las acciones y los atributos que deben incluirse en la política. A continuación, la consola de
DynamoDB genera una política que puede asociar a un rol de IAM.

1. Inicie sesión en laAWS Management Consoley abra la consola de DynamoDB enhttps://


console.aws.amazon.com/dynamodb/.
2. En el panel de navegación, elija Tables (Tablas).
3. En la lista de tablas, elija aquella para la que desea crear la política de IAM.
4. Elija la pestaña Access control (Control de acceso).
5. Elija el proveedor de identidades, las acciones y los atributos de la política.

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.

Cómo escribir la aplicación para usar las identidades web federadas


Para utilizar las identidades web federadas, la aplicación debe asumir el rol de IAM que ha creado. A partir
de ese momento, la aplicación respetará la política de acceso que se haya asociado al rol.

En tiempo de ejecución, si la aplicación utiliza identidades web federadas, deberá seguir estos pasos:

1. Autenticarse ante el proveedor de identidades tercero. La aplicación debe llamar al proveedor de


identidades mediante una interfaz proporcionada por este último. La forma exacta en la que se lleva
a cabo la autenticación del usuario depende del proveedor y de la plataforma en la que se ejecute la
aplicación. Por lo general, si el usuario aún no ha iniciado sesión, el proveedor de identidades (IdP) se
encarga de mostrar una página de inicio de sesión propia.

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

Versión de API 2012-08-10


923
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management

A continuación se muestra un ejemplo de una solicitud y la respuesta de una acción


AssumeRoleWithWebIdentity en AWS STS . El token de identidad web se obtuvo del proveedor de
identidades Login with Amazon.

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:

Variable de política Ejemplo de valor

${www.amazon.com:user_id} amzn1.account.AGJZDKHJKAUUSW6C44CHPEXAMPLE

${graph.facebook.com:id} 123456789

${accounts.google.com:sub} 123456789012345678901

Versión de API 2012-08-10


924
Amazon DynamoDB Guía para desarrolladores
Identity and Access Management os en DAX

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.

Identity and Access Management


El Accelerador de DynamoDB (DAX) está diseñado para funcionar conjuntamente con DynamoDB,
con el fin de agregar de forma transparente una capa de almacenamiento en caché a las aplicaciones.
Sin embargo, DAX y DynamoDB tienen mecanismos distintos de control de acceso. Ambos servicios
utilizanAWS Identity and Access Management(IAM) para implementar sus respectivas políticas de
seguridad, pero los modelos de seguridad de DAX y DynamoDB son distintos.

Para obtener más información acerca de Identity and Access Management en DAX, consulteControl de
acceso DAX (p. 814).

Validación de conformidad por sector para


DynamoDB
Hay auditores externos que evalúan la seguridad y la conformidad de DynamoDB en
diferentesAWSprogramas de cumplimiento, incluidos los siguientes:

• Controles del Sistema y Organizaciones (System and Organization Controls, SOC)


• Industria de tarjetas de pago (PCI)
• Programa Federal de Administración de Riesgos y Autorizaciones (Federal Risk and Authorization
Management Program, FedRAMP)
• Ley de Portabilidad y Responsabilidad de Seguros Médicos de EE. UU (Health Insurance Portability and
Accountability Act, HIPAA).

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.

Su responsabilidad de conformidad al utilizar DynamoDB se determina en función de la sensibilidad de


los datos, los objetivos de conformidad de su organización, así como de la legislación y los reglamentos
aplicables. Si su uso de DynamoDB está sujeto a conformidad con estándares tales como HIPAA, PCI o
FedRAMP,AWSproporciona recursos para ayudar a:

• Guías de inicio rápido de seguridad y conformidad: guías de implementación que incluyen


consideraciones sobre arquitectura y ofrecen pasos para implementar entornos de referencia centrados
en la seguridad y la conformidad enAWS.
• Documento técnico de Architecting for HIPAA Security and Compliance— Un documento técnico que
describe cómo las empresas pueden usarAWSPara crear aplicaciones que se ajusten al estándar
HIPAA.
• AWSRecursos de conformidad de: un conjunto de manuales y guías que podría aplicarse a su sector y
ubicación.

Versión de API 2012-08-10


925
Amazon DynamoDB Guía para desarrolladores
Resiliencia

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

Resiliencia y recuperación ante desastres en


Amazon DynamoDB
LaAWSLa infraestructura global de está conformada porAWSRegiones y zonas de disponibilidad.AWS
Las regiones de proporcionan varias zonas de disponibilidad físicamente independientes y aisladas que
se encuentran conectadas mediante redes con un alto nivel de rendimiento y redundancia, además de
baja latencia. Con las zonas de disponibilidad, puede diseñar y utilizar aplicaciones y bases de datos
que realizan una conmutación por error automática entre zonas de disponibilidad sin interrupciones. Las
zonas de disponibilidad tienen una mayor disponibilidad, tolerancia a errores y escalabilidad que las
infraestructuras tradicionales de centros de datos únicos o múltiples.

Si necesita replicar datos o aplicaciones sobre grandes distancias geográficas, utiliceAWSRegiones


de locales. UnaAWSLa región local es un único centro de datos diseñado para complementar
unAWSRegión . Como todosAWSRegiones deAWSLas regiones locales están completamente aisladas de
otrasAWSRegiones de.

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.

Backup y restauración bajo demanda

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

La recuperación a un momento dado ayuda a proteger las tablas de DynamoDB de operaciones


accidentales de escritura o eliminación. Al habilitar la recuperación a un momento dado, ya no hay que
preocuparse por crear, mantener o planificar backups bajo demanda. Para obtener más información,
consulteRecuperación a un momento dado para DynamoDB.

Seguridad de la infraestructura en Amazon


DynamoDB
Como servicio gestionado, Amazon DynamoDB está protegido por laAWSProcedimientos de seguridad
de red globales que se describen en laAmazon Web Services: Información general de procesos de
seguridadDocumento técnico.

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.

Versión de API 2012-08-10


926
Amazon DynamoDB Guía para desarrolladores
Uso de puntos de enlace de la VPC

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

Uso de puntos de enlace de Amazon VPC para


obtener acceso a DynamoDB
Por razones de seguridad, muchosAWSSus aplicaciones se ejecutan en un entorno de Amazon Virtual
Private Cloud (Amazon VPC). Con Amazon VPC, puede lanzar instancias de Amazon EC2 en una nube
virtual privada que está aislada de forma lógica de otras redes, incluida la red pública de Internet. Con
una VPC de Amazon, puede controlar el rango de direcciones IP, las subredes, las tablas de ruteo, las
gateways de red y los ajustes de seguridad.
Note

Si ha creado suAWSDespués del 4 de diciembre de 2013, ya dispone de una VPC


predeterminada en cadaAWSRegión . Una VPC predeterminada está lista para usarse; puede
comenzar de inmediato a usarla sin tener que realizar ningún paso de configuración adicional.
Para obtener más información, consulteVPC predeterminada y subredes predeterminadasen
laGuía del usuario de Amazon VPC.

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.

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 SSL/TLS. En el siguiente diagrama se
muestra cómo una instancia EC2 de una VPC obtiene acceso a 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

Versión de API 2012-08-10


927
Amazon DynamoDB Guía para desarrolladores
Uso de puntos de enlace de la VPC

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

Tutorial: Uso de un punto de conexión de la VPC para


DynamoDB
En esta sección se explica cómo configurar y usar un punto de conexión de la VPC para DynamoDB.

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)

Versión de API 2012-08-10


928
Amazon DynamoDB Guía para desarrolladores
Uso de puntos de enlace de la VPC

Paso 1: Lanzamiento de una instancia de Amazon EC2


En este paso, lanza una instancia de Amazon EC2 en su Amazon VPC predeterminada. A partir de ese
momento, puede crear y utilizar un punto de conexión de la VPC para DynamoDB.

1. Abra la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/.


2. Elija Launch Instance y proceda del modo siguiente:

Paso 1: Elegir una imagen de máquina de Amazon (AMI)

• En la parte superior de la lista de AMI, vaya a Amazon Linux AMI (AMI de Amazon Linux) y elija
Select (Seleccionar).

Paso 2: Página Choose an Instance Type

• En la parte superior de la lista de tipos de instancias, elija t2.micro.


• Seleccione Next (Siguiente): Página Configure Instance Details (Configurar los detalles de la
instancia).

Paso 3: Página Configure Instance Details (Configurar los detalles de la instancia)

• Vaya a Network (Red) y elija la VPC predeterminada.

Seleccione Next (Siguiente): Adición de almacenamiento.

Paso 4: Adición de almacenamiento

• Elija para omitir este paso.Siguiente: Página Tag Instance (Instancia de etiqueta).

Paso 5: Página Tag Instance (Instancia de etiqueta)

• Elija para omitir este paso.Siguiente: Página Configure Security Group (Configurar grupo de
seguridad).

Paso 6: Página Configure Security Group (Configurar grupo de seguridad)

• Elija Select an existing security group.


• En la lista de grupos de seguridad, elija default. Se trata del grupo de seguridad predeterminado
para la VPC.
• Seleccione Next (Siguiente): Revisión y lanzamiento.

Paso 7: Página Review Instance Launch (Revisar lanzamiento de instancia)

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

Versión de API 2012-08-10


929
Amazon DynamoDB Guía para desarrolladores
Uso de puntos de enlace de la VPC

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

Paso 2: Configuración de la instancia de Amazon EC2


Una vez que la instancia de Amazon EC2 esté disponible, podrá iniciar sesión en ella y prepararla para
utilizarla por primera vez.
Note

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.

a. En el panel de navegación, elija Security Groups.


b. Elija Create Security Group (Crear grupo de seguridad). En la ventana Create Security Group,
haga lo siguiente:

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

Cuando esté conforme con los ajustes, elija Create (Crear).


c. En el panel de navegación, elija Instances (Instancias).
d. Elija la instancia Amazon EC2 que ha lanzado enPaso 1: Lanzamiento de una instancia de
Amazon EC2 (p. 929).
e. Seleccione Actions --> Networking --> Change Security Groups.
f. En el navegadorCambiar grupos de seguridad, seleccione el grupo de seguridad que ha creado
anteriormente en este procedimiento (por ejemplo: my-ssh-access). EldefaultEl grupo de
seguridad también debe estar seleccionado. Cuando la configuración sea la que desea, elija
Assign Security Groups.
2. UsarsshPara iniciar sesión en la instancia de Amazon EC2, como se muestra en el siguiente ejemplo.

ssh -i my-keypair.pem ec2-user@public-dns-name


Versión de API 2012-08-10
930
Amazon DynamoDB Guía para desarrolladores
Uso de puntos de enlace de la VPC

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

El identificador de inicio de sesión es ec2-user. No se requiere contraseña.


3. Configure elAWSLas credenciales tal y como se muestra a continuación. Escriba suAWSId. de clave
de acceso, clave secreta y nombre de la región predeterminada cuando se le solicite.

aws configure

AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE


AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-east-1
Default output format [None]:

Ahora está listo para crear un punto de conexión de la VPC para DynamoDB.

Paso 3: Creación de un punto de conexión de la VPC para DynamoDB


En este paso, creará un punto de conexión de la VPC para DynamoDB y lo probará para asegurarse de
que funciona.

1. Antes de empezar, compruebe que puede comunicarse con DynamoDB mediante su punto de enlace
público.

aws dynamodb list-tables

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

aws ec2 describe-vpc-endpoint-services

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

aws ec2 describe-vpcs

{
"Vpcs": [
{
"VpcId": "vpc-0bbc736e",
"InstanceTenancy": "default",
"State": "available",
"DhcpOptionsId": "dopt-8454b7e1",
"CidrBlock": "172.31.0.0/16",
"IsDefault": true
}

Versión de API 2012-08-10


931
Amazon DynamoDB Guía para desarrolladores
Uso de puntos de enlace de la VPC

]
}

En el resultado de ejemplo, el ID de la VPC es vpc-0bbc736e.


4. Cree el punto de conexión de la VPC. Para el parámetro --vpc-id, especifique el ID de la VPC del
paso anterior. Utilice el parámetro --route-table-ids para asociar el punto de enlace con las
tablas de enrutamiento.

aws ec2 create-vpc-endpoint --vpc-id vpc-0bbc736e --service-name com.amazonaws.us-


east-1.dynamodb --route-table-ids rtb-11aa22bb

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

aws dynamodb list-tables

Si lo desea, puede probar otrosAWS CLIpara DynamoDB. Para obtener más información, consulte la
Referencia de comandos de la AWS CLI.

Paso 4: (Opcional) Limpieza


Si desea eliminar los recursos que ha creado en este tutorial, siga estos procedimientos:

Para eliminar el punto de conexión de la VPC para DynamoDB

1. Inicie sesión en la instancia de Amazon EC2.


2. Determine el ID de punto de conexión de la VPC.

aws ec2 describe-vpc-endpoints

{
"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"
}
}

En el resultado de ejemplo, el ID de punto de conexión de la VPC es vpce-9b15e2f2.


Versión de API 2012-08-10
932
Amazon DynamoDB Guía para desarrolladores
Configuración y análisis de vulnerabilidades

3. Elimine el punto de conexión de la VPC.

aws ec2 delete-vpc-endpoints --vpc-endpoint-ids vpce-9b15e2f2

{
"Unsuccessful": []
}

La matriz vacía [] indica que la operación se ha realizado correctamente (no hay solicitudes con
error).

Para terminar la instancia de Amazon EC2

1. Abra la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/.


2. En el panel de navegación, elija Instances (Instancias).
3. Seleccione la instancia Amazon EC2.
4. Elija Actions (Acciones), Instance State (Estado de la instancia), Terminate (Terminar).
5. En la ventana de confirmación, elija Yes, Terminate.

Configuración y análisis de vulnerabilidades en


Amazon DynamoDB
AWS gestiona las tareas de seguridad básicas como la aplicación de parches en la base de datos y el
sistema operativo (SO) de invitado, la configuración del firewall y la recuperación de desastres. Estos
procedimientos han sido revisados y certificados por los terceros pertinentes. Para obtener más detalles,
consulte los siguientes recursos:

• Validación de conformidad para Amazon DynamoDB


• Modelo de responsabilidad compartida
• Amazon Web Services: Información general de los procesos de seguridad(documento técnico)

Las siguientes prácticas recomendadas sobre seguridad también evaluan la configuración y los análisis de
vulnerabilidades en Amazon DynamoDB:

• Controle el cumplimiento de DynamoDB AWS Config Rules


• Controlar la configuración de DynamoDB AWS Config

Prácticas recomendadas de seguridad para


Amazon DynamoDB
Amazon DynamoDB cuenta con una serie de características de seguridad que debe tener en cuenta
a la hora de desarrollar e implementar sus propias políticas de seguridad. Las siguientes prácticas
recomendadas son directrices generales y no suponen una solución de seguridad completa. Puesto que es
posible que estas prácticas recomendadas no sean adecuadas o suficientes para el entorno, considérelas
como consideraciones útiles en lugar de como normas.

Temas

Versión de API 2012-08-10


933
Amazon DynamoDB Guía para desarrolladores
Prácticas recomendadas preventivas de seguridad de

• PrácDynamoDB adas preventivas de seguridad preventiva (p. 934)


• Prácticas recomendadas de seguridad de DynamoDB (p. 935)

PrácDynamoDB adas preventivas de seguridad


preventiva
Las siguientes prácticas recomendadas pueden ayudarlo a anticiparse y prevenir incidentes de seguridad
en Amazon DynamoDB.

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.

Puede especificar si DynamoDB debe utilizar unAWS(tipo de cifrado predeterminado) o unAWSCMK


administrado para cifrar los datos del usuario. Para obtener más información, consulte Cifrado en
reposo de Amazon DynamoDB.
Uso de los roles de IAM para autenticar acceso a DynamoDB

Para usuarios, aplicaciones y otrosAWSpara acceder a DynamoDB, deben incluirAWS credentials


in their AWSSolicitudes de API No debe almacenarAWSCredenciales de Estas son las credenciales
a largo plazo que no rotan automáticamente y, por lo tanto, podrían tener un impacto empresarial
significativo si se comprometen. Un rol de IAM le permite obtener claves de acceso temporal que se
pueden utilizar para tener accesoAWSServicios y recursos de.

Para obtener más información, consulteAutenticación.


Usar directivas de IAM para la autorización base de DynamoDB

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.

Puede hacerlo utilizando lo siguiente:


• AWS Políticas administradas
• Políticas administradas por el cliente
Uso de las condiciones de políticas de IAM para control de acceso preciso

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.

Versión de API 2012-08-10


934
Amazon DynamoDB Guía para desarrolladores
Prácticas recomendadas de detección de seguridad

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.

Para obtener más información, consultePuntos de enlace para Amazon DynamoDB.


Considere el cifrado del lado del cliente

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.

Prácticas recomendadas de seguridad de DynamoDB


Las siguientes prácticas recomendadas para Amazon DynamoDB le pueden ser de utilidad para detectar
los incidentes y los posibles puntos débiles de la seguridad.

UsarAWS CloudTrailMonitorizaciónAWSuso de clave KMS administrado

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

Versión de API 2012-08-10


935
Amazon DynamoDB Guía para desarrolladores
Prácticas recomendadas de detección de seguridad

IP de procedencia de la solicitud, etc. Para obtener más información, consulteRegistro deAWS


KMSLlamadas a la APIAWS CloudTraily laAWS CloudTrailGuía del usuario.
Supervisar las operaciones de DynamoDB con CloudTrail

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.

Cuando se produce una actividad en DynamoDB, dicha actividad se registra en un evento de


CloudTrail junto conAWSen el historial de eventos. Para obtener más información, consulteRegistro
de operaciones de DynamoDBAWS CloudTrail. Puede ver, buscar y descargar los últimos eventos de
la cuenta de AWS. Para obtener más información, consulteVer eventos con el historial de eventos de
CloudTrailen laAWS CloudTrailGuía del usuario.

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

UsoAWS Config, puede monitorear y registrar continuamente los cambios de configuración de


suAWSde AWS. También puede utilizarAWS ConfigPara realizar un inventarioAWSde AWS.
Cuando se detecta un cambio con respecto a un estado anterior, se puede enviar una notificación
de Amazon Simple Notification Service (Amazon SNS) para que la revise y tome medidas. Siga la
guíaConfiguraciónAWS ConfigCon la consola, asegurando que se incluyan los tipos de recursos de
DynamoDB.

Puede configurarAWS ConfigPara transmitir cambios de configuración y notificaciones a un tema de


Amazon SNS. Por ejemplo, cuando se actualiza un recurso, puede obtener una notificación enviada
a su correo electrónico, para que pueda ver los cambios. También se le puede notificar cuando AWS
Config evalúa las reglas personalizadas o administradas con respecto a sus recursos.

Para ver un ejemplo, consulte .NotificacionesAWS ConfigEnvíos a un tema de Amazon SNSen laAWS
ConfigGuía para desarrolladores.

Versión de API 2012-08-10


936
Amazon DynamoDB Guía para desarrolladores
Prácticas recomendadas de detección de seguridad

Controle el cumplimiento de DynamoDBAWS ConfigReglas de

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.

Para obtener más información, consulteAWSEstrategias de etiquetadoyEtiquetado de DynamoDB.

Versión de API 2012-08-10


937
Amazon DynamoDB Guía para desarrolladores
Registro y monitorización en DynamoDB

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)

Registro y monitorización en DynamoDB


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 monitoreo de todas las
partes de suAWSPara que pueda depurar con mayor facilidad un error de múltiples puntos, si ocurre
alguno. Antes de comenzar a monitorear DynamoDB, debe crear un plan de monitoreo que incluya
respuestas a las siguientes preguntas:

• ¿Cuáles son los objetivos de la monitorización?


• ¿Qué recursos va a monitorizar?
• ¿Con qué frecuencia va a monitorizar estos recursos?
• ¿Qué herramientas de monitorización va a utilizar?
• ¿Quién se encargará de realizar las tareas de monitorización?
• ¿Quién debería recibir una notificación cuando surjan problemas?

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:

• El número de unidades de capacidad de lectura o escritura usadas durante el periodo de tiempo


especificado, para que pueda saber cuánta capacidad de desempeño provisionada se usa.
• Las solicitudes que superan la capacidad aprovisionada de lectura o escritura de una tabla durante el
periodo especificado, para que pueda determinar qué solicitudes superan las cuotas de rendimiento
aprovisionado de una tabla.
• Los errores del sistema, para poder determinar si alguna solicitud ha dado lugar a un error.

Temas
• Herramientas de monitorización (p. 939)
• Monitorización con Amazon CloudWatch (p. 940)
• Registro de operaciones de DynamoDB utilizandoAWS CloudTrail (p. 964)

Versión de API 2012-08-10


938
Amazon DynamoDB Guía para desarrolladores
Herramientas de monitorización

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.

Herramientas de monitorización automatizadas


Puede utilizar las siguientes herramientas de monitorización automatizada para monitorizar DynamoDB e
informar cuando haya algún problema:

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

Herramientas de monitorización manual


Otra parte importante del monitoreo de DynamoDB implica la monitorización manual de los elementos que
no cubren las alarmas de CloudWatch. DynamoDB, CloudWatchTrusted Advisor, y otrosAWSLos paneles
de consola de proporcionan una vista rápida del estado de suAWSMedio ambiente. Es recomendable que
también compruebe los archivos de registro de Amazon DynamoDB.

• 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

Además, puede utilizar CloudWatch para hacer lo siguiente:


• Crear paneles personalizados para monitorear los servicios que le interesan.
• Realizar un gráfico con los datos de las métricas para resolver problemas y descubrir tendencias
• Buscar y examinar todas susAWSMétricas de recursos

Versión de API 2012-08-10


939
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

• Crear y editar las alarmas de notificación de problemas

Monitorización con Amazon CloudWatch


Puede monitorear Amazon DynamoDB utilizando CloudWatch, que recopila y procesa los datos sin formato
de DynamoDB en métricas legibles y casi en tiempo real. Estas estadísticas se conservan durante un
periodo de tiempo, de forma que pueda disponer de información histórica y obtener una mejor perspectiva
sobre el rendimiento de la aplicación o servicio web. De forma predeterminada, los datos de las métricas
de DynamoDB se envían a CloudWatch automáticamente. Para obtener más información, consulte¿Qué
es Amazon CloudWatch?yRetención de métricasen laGuía del usuario de Amazon CloudWatch.

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)

Dimensiones y métricas de DynamoDB


Cuando interactúa con DynamoDB, este envía las siguientes métricas y dimensiones a CloudWatch.
Puede seguir los siguientes procedimientos para ver las métricas de DynamoDB.

Para ver las métricas (consola)

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.

1. Abra la consola de CloudWatch en https://console.aws.amazon.com/cloudwatch/.


2. En el panel de navegación, seleccione Metrics (Métricas).
3. Seleccione el espacio de nombres DynamoDB.

Para ver las métricas (CLI)

• En el símbolo del sistema, ejecute el siguiente comando:

aws cloudwatch list-metrics --namespace "AWS/DynamoDB"

CloudWatch muestra las siguientes métricas para DynamoDB:

Dimensiones y métricas de DynamoDB


A continuación aparece una lista de dimensiones y métricas que DynamoDB envía a Amazon CloudWatch.

Métricas de DynamoDB
Note

Amazon CloudWatch agrega las siguientes métricas de DynamoDB a intervalos de un minuto:

• ConditionalCheckFailedRequests
• ConsumedReadCapacityUnits
• ConsumedWriteCapacityUnits
• ReadThrottleEvents

Versión de API 2012-08-10


940
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

• ReturnedBytes
• ReturnedItemCount
• ReturnedRecordsCount
• SuccessfulRequestLatency
• SystemErrors
• TimeToLiveDeletedItemCount
• ThrottledRequests
• TransactionConflict
• UserErrors
• WriteThrottleEvents

Para todas las demás métricas de DynamoDB, la granularidad de acumulación es de cinco


minutos.

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

AccountMaxReads Número máximo de unidades de capacidad de lectura que


puede utilizar una cuenta. Este límite no se aplica a las tablas
a demanda ni a los índices secundarios globales.

Unidades:Count

Estadísticas válidas:

• Maximum— El número máximo de unidades de capacidad


de lectura que puede utilizar una cuenta.

AccountMaxTableLevelReads Número máximo de unidades de capacidad de lectura que


puede utilizar una tabla o un índice secundario global de
una cuenta. Para tablas bajo demanda, este límite limita el
máximo de unidades de solicitud de lectura que puede utilizar
una tabla o un índice secundario global.

Unidades:Count

Estadísticas válidas:

• Maximum— El número máximo de unidades de capacidad


de lectura que puede utilizar una tabla o un índice
secundario global de la cuenta.

AccountMaxTableLevelWrites Número máximo de unidades de capacidad de escritura que


puede utilizar una tabla o un índice secundario global de una
cuenta. Para las tablas bajo demanda, este límite limita las
unidades máximas de solicitud de escritura que puede utilizar
una tabla o un índice secundario global.

Unidades:Count

Estadísticas válidas:

Versión de API 2012-08-10


941
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

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.

AccountMaxWrites Número máximo de unidades de capacidad de escritura que


puede utilizar una cuenta. Este límite no se aplica a las tablas
a demanda ni a los índices secundarios globales.

Unidades:Count

Estadísticas válidas:

• Maximum— El número máximo de unidades de capacidad


de escritura que puede utilizar una cuenta.

Porcentaje de unidades de capacidad de lectura


AccountProvisionedReadCapacityUtilization
aprovisionadas que usa una cuenta.

Unidades:Percent

Estadísticas válidas:

• MaximumPorcentaje máximo de unidades de capacidad de


lectura aprovisionadas utilizadas por la cuenta.
• MinimumPorcentaje mínimo de unidades de capacidad de
lectura aprovisionadas utilizadas por la cuenta.
• AveragePorcentaje medio de unidades de capacidad de
lectura aprovisionadas utilizadas por la cuenta. La métrica
se publica por intervalos de cinco minutos. Por lo tanto, si
ajusta rápidamente las unidades de capacidad de lectura
aprovisionadas, es posible que esta estadística no refleje el
promedio real.

Porcentaje de unidades de capacidad de escritura


AccountProvisionedWriteCapacityUtilization
provisionadas que usa una cuenta.

Unidades:Percent

Estadísticas válidas:

• MaximumPorcentaje máximo de unidades de capacidad de


escritura aprovisionadas utilizadas por la cuenta.
• MinimumPorcentaje mínimo de unidades de capacidad de
escritura aprovisionadas utilizadas por la cuenta.
• AveragePorcentaje medio de unidades de capacidad de
escritura aprovisionadas utilizadas por la cuenta. La métrica
se publica por intervalos de cinco minutos. Por lo tanto, si
ajusta rápidamente las unidades de capacidad de escritura
aprovisionadas, es posible que esta estadística no refleje el
promedio real.

Versión de API 2012-08-10


942
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

AgeOfOldestUnreplicatedRecord El tiempo transcurrido desde que un registro que aún no se


replicó en la secuencia de datos de Kinesis apareció por
primera vez en la tabla DynamoDB.

Unidades:Milliseconds

Dimensiones: TableName, DelegatedOperation

Estadísticas válidas:

• Maximum.
• Minimum.
• Average.

ConditionalCheckFailedRequests Número de intentos fallidos para realizar escrituras


condicionales. LaPutItem,UpdateItem,
yDeleteItempermiten proporcionar una condición lógica
que debe evaluarse como verdadera antes de que la
operación pueda continuar. Si esta condición se evalúa como
false,ConditionalCheckFailedRequestsse incrementa
en uno.ConditionalCheckFailedRequeststambién se
incrementa en uno para las instrucciones PartiQL Update
y Delete donde se proporciona una condición lógica y esa
condición se evalúa como falsa.
Note

Una escritura condicional errónea dará


lugar a un error HTTP 400 (solicitud
errónea). Estos eventos se reflejan en
elConditionalCheckFailedRequests, pero no
en elUserErrorsMétrica de.

Unidades:Count

Dimensiones: TableName

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

Versión de API 2012-08-10


943
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

ConsumedChangeDataCaptureUnits El número de unidades de captura de datos de cambio


consumidas.

Unidades:Count

Dimensiones: TableName, DelegatedOperation

Estadísticas válidas:

• Minimum
• Maximum
• Average

Versión de API 2012-08-10


944
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

ConsumedReadCapacityUnits El número de unidades de capacidad de lectura usadas


durante el periodo de tiempo especificado, para que pueda
saber cuánta capacidad de desempeño provisionada se usa.
Puede recuperar la capacidad total de lectura consumida para
una tabla y todos sus índices secundarios globales, o para
un índice secundario global determinado. Para obtener más
información, consulte Modo de capacidad de lectura/escritura.

LaTableName dimension returns the


ConsumedReadCapacityUnitspara la tabla,
pero no para ningún índice secundario global.
Para verConsumedReadCapacityUnitspara
un índice secundario global, debe
especificarTableNameyGlobalSecondaryIndex.
Note

UsarSumpara calcular el rendimiento consumido.


Por ejemplo, obtenga elSumen un lapso
de un minuto y dividirlo por el número de
segundos en un minuto (60) para calcular el
promedioConsumedReadCapacityUnitspor
segundo (reconociendo que este promedio no
resalta los picos grandes pero breves en la actividad
de lectura que ocurrieron durante ese minuto).
Puede comparar el valor calculado con el valor
de rendimiento aprovisionado que proporciona
DynamoDB.

Unidades:Count

Dimensiones: TableName, GlobalSecondaryIndexName

Estadísticas válidas:

• MinimumNúmero mínimo de unidades de capacidad de


lectura consumidas por cualquier solicitud individual a la
tabla o el índice.
• MaximumNúmero máximo de unidades de capacidad de
lectura consumidas por cualquier solicitud individual a la
tabla o el índice.
• Average— La capacidad de lectura media por solicitud
consumida.
Note

LaAverageestá influenciado por períodos de


inactividad donde el valor de la muestra será cero.
• Sum— El total de unidades de capacidad de
lectura consumidas. Esta es la estadística más útil
paraConsumedReadCapacityUnitsMétrica de.
• SampleCount— El número de solicitudes de lectura a
DynamoDB, incluso si no se ha consumido capacidad de
lectura.

Versión de API 2012-08-10


945
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción
Note

LaSampleCountestá influenciado por períodos de


inactividad donde el valor de la muestra será cero.

Versión de API 2012-08-10


946
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

ConsumedWriteCapacityUnits El número de unidades de capacidad de escritura usadas


durante el periodo de tiempo especificado, para que pueda
saber cuánta capacidad de desempeño provisionada se usa.
Puede recuperar la capacidad de escritura total consumida
para una tabla y todos sus índices secundarios globales, o
para un índice secundario global determinado. Para obtener
más información, consulte Modo de capacidad de lectura/
escritura.

LaTableName dimension returns the


ConsumedWriteCapacityUnitspara la tabla,
pero no para ningún índice secundario global.
Para verConsumedWriteCapacityUnitspara
un índice secundario global, debe
especificarTableNameyGlobalSecondaryIndex.
Note

UsarSumpara calcular el rendimiento consumido.


Por ejemplo, obtenga elSumen un lapso
de un minuto y dividirlo por el número de
segundos en un minuto (60) para calcular el
promedioConsumedWriteCapacityUnitspor
segundo (reconociendo que este promedio no
resalta ningún pico grande pero breve en la actividad
de escritura que ocurriera durante ese minuto).
Puede comparar el valor calculado con el valor
de rendimiento aprovisionado que proporciona
DynamoDB.

Unidades:Count

Dimensiones: TableName, GlobalSecondaryIndexName

Estadísticas válidas:

• MinimumNúmero mínimo de unidades de capacidad de


escritura consumidas por cualquier solicitud individual a la
tabla o el índice.
• MaximumNúmero máximo de unidades de capacidad de
escritura consumidas por cualquier solicitud individual en la
tabla o el índice.
• Average— La capacidad media de escritura por solicitud
consumida.
Note

LaAverageestá influenciado por períodos de


inactividad donde el valor de la muestra será cero.
• Sum— Las unidades de capacidad de escritura
totales consumidas. Esta es la estadística más útil
paraConsumedWriteCapacityUnitsMétrica de.
• SampleCount— El número de solicitudes de escritura en
DynamoDB, incluso si no se ha consumido capacidad de
escritura.

Versión de API 2012-08-10


947
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción
Note

LaSampleCountestá influenciado por períodos de


inactividad donde el valor de la muestra será cero.

Porcentaje de unidades de capacidad de lectura


MaxProvisionedTableReadCapacityUtilization
aprovisionadas utilizadas por la tabla de lectura aprovisionada
más alta o el índice secundario global de una cuenta.

Unidades:Percent

Estadísticas válidas:

• Maximum—: porcentaje máximo de unidades de capacidad


de lectura aprovisionadas utilizadas por la tabla de lectura
aprovisionada más alta de la cuenta.
• Minimum— El porcentaje mínimo de unidades de
capacidad de lectura aprovisionadas utilizadas por la tabla
de lectura aprovisionada más alta de la cuenta.
• Average— Porcentaje medio de unidades de capacidad
de lectura aprovisionadas utilizadas por la tabla de lectura
aprovisionada más alta de la cuenta. La métrica se
publica por intervalos de cinco minutos. Por lo tanto, si
ajusta rápidamente las unidades de capacidad de lectura
aprovisionadas, es posible que esta estadística no refleje el
promedio real.

Porcentaje de capacidad de escritura aprovisionada utilizada


MaxProvisionedTableWriteCapacityUtilization
por la tabla de escritura aprovisionada más alta o el índice
secundario global de una cuenta.

Unidades:Percent

Estadísticas válidas:

• Maximum— El porcentaje máximo de unidades de


capacidad de escritura aprovisionadas utilizadas por
la tabla de escritura aprovisionada más alta o el índice
secundario global de una cuenta.
• Minimum— El porcentaje mínimo de unidades de
capacidad de escritura aprovisionadas utilizadas por
la tabla de escritura aprovisionada más alta o el índice
secundario global de una cuenta.
• Average— Porcentaje medio de unidades de capacidad de
escritura aprovisionadas utilizadas por la tabla de escritura
aprovisionada más alta o el índice secundario global de
la cuenta. La métrica se publica por intervalos de cinco
minutos. Por lo tanto, si ajusta rápidamente las unidades de
capacidad de escritura aprovisionadas, es posible que esta
estadística no refleje el promedio real.

Versión de API 2012-08-10


948
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

OnlineIndexConsumedWriteCapacityNúmero de unidades de capacidad de escritura consumidas


al agregar un nuevo índice secundario global a una tabla. Si
la capacidad de escritura del índice es demasiado baja, es
posible que se limite la actividad de escritura entrante durante
la fase de relleno. Esto puede aumentar el tiempo que se
tarda en crear el índice. Debe supervisar esta estadística
mientras se está construyendo el índice para determinar si la
capacidad de escritura del índice no está aprovisionada.

Puede ajustar la capacidad de escritura del índice usando


elUpdateTable, incluso mientras el índice todavía se está
construyendo.

LaConsumedWriteCapacityUnitspara el índice no incluye


el rendimiento de escritura consumido durante la creación del
índice.

Unidades:Count

Dimensiones: TableName, GlobalSecondaryIndexName

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

OnlineIndexPercentageProgress Porcentaje de finalización cuando se agrega un nuevo índice


secundario global a una tabla. DynamoDB primero debe
asignar recursos para el nuevo índice y, a continuación,
rellenar los atributos de la tabla en el índice. En el caso de
las tablas de gran tamaño, este proceso puede llevar mucho
tiempo. Debe supervisar esta estadística para ver el progreso
relativo a medida que DynamoDB crea el índice.

Unidades:Count

Dimensiones: TableName, GlobalSecondaryIndexName

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

Versión de API 2012-08-10


949
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

OnlineIndexThrottleEvents El número de eventos de aceleración de escritura que se


producen al agregar un nuevo índice secundario global a una
tabla. Estos eventos indican que la creación del índice tardará
más en completarse, ya que la actividad de escritura entrante
excede el rendimiento de escritura aprovisionado del índice.

Puede ajustar la capacidad de escritura del índice usando


elUpdateTable, incluso mientras el índice todavía se está
construyendo.

LaWriteThrottleEventspara el índice no incluye ningún


evento de aceleración que se produzca durante la creación
del índice.

Unidades:Count

Dimensiones: TableName, GlobalSecondaryIndexName

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

PendingReplicationCount (Esta métrica es para tablas globales de DynamoDB.) El


número de actualizaciones de elementos que se escriben en
la tabla de réplica pero que todavía no se han escrito en otra
réplica de la tabla global.

Unidades:Count

Dimensiones: TableName, ReceivingRegion

Estadísticas válidas:

• Average
• Sample Count
• Sum

Versión de API 2012-08-10


950
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

ProvisionedReadCapacityUnits Número de unidades de capacidad de lectura aprovisionadas


para una tabla o un índice secundario global.
LaTableName dimension returns the
ProvisionedReadCapacityUnitspara la tabla,
pero no para ningún índice secundario global.
Para verProvisionedReadCapacityUnitspara
un índice secundario global, debe
especificarTableNameyGlobalSecondaryIndex.

Unidades:Count

Dimensiones: TableName, GlobalSecondaryIndexName

Estadísticas válidas:

• Minimum— La configuración más baja para la capacidad


de lectura provisionada. Si usaUpdateTablepara
aumentar la capacidad de lectura, esta métrica muestra
el valor más bajo deReadCapacityUnitsDurante este
periodo de tiempo.
• Maximum— La configuración más alta para la capacidad de
lectura provisionada. Si usaUpdateTablepara disminuir
la capacidad de lectura, esta métrica muestra el valor más
alto deReadCapacityUnitsDurante este periodo de
tiempo.
• Average— La capacidad de lectura provisionada media.
LaProvisionedReadCapacityUnitsLa métrica se
publica a intervalos de cinco minutos. Por lo tanto, si
ajusta rápidamente las unidades de capacidad de lectura
aprovisionadas, es posible que esta estadística no refleje el
promedio real.

Versión de API 2012-08-10


951
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

ProvisionedWriteCapacityUnits Número de unidades de capacidad de escritura


aprovisionadas para una tabla o un índice secundario global.

LaTableName dimension returns the


ProvisionedWriteCapacityUnitspara la tabla,
pero no para ningún índice secundario global. Para
verProvisionedWriteCapacityUnitspara
un índice secundario global, debe
especificarTableNameyGlobalSecondaryIndex.

Unidades:Count

Dimensiones: TableName, GlobalSecondaryIndexName

Estadísticas válidas:

• Minimum— La configuración más baja para la capacidad


de escritura aprovisionada. Si usaUpdateTablepara
aumentar la capacidad de escritura, esta métrica muestra
el valor más bajo deWriteCapacityUnitsDurante este
periodo de tiempo.
• Maximum— La configuración más alta para la capacidad de
escritura aprovisionada. Si usaUpdateTablepara disminuir
la capacidad de escritura, esta métrica muestra el valor
más alto deWriteCapacityUnitsDurante este periodo
de tiempo.
• Average— La capacidad media de escritura
aprovisionada. LaProvisionedWriteCapacityUnitsLa
métrica se publica a intervalos de cinco minutos. Por lo
tanto, si ajusta rápidamente las unidades de capacidad de
escritura aprovisionadas, es posible que esta estadística no
refleje el promedio real.

Versión de API 2012-08-10


952
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

ReadThrottleEvents Solicitudes a DynamoDB que superen las unidades de


capacidad de lectura aprovisionadas para una tabla o un
índice secundario global.

Una sola solicitud puede dar lugar a múltiples eventos.


Por ejemplo, unBatchGetItemque dice 10 elementos
se procesa como 10GetItemrápidamente. Para cada
evento,ReadThrottleEventsse incrementa en uno si ese
evento está limitado. LaThrottledRequestsmétrica para
toda laBatchGetItemno se incrementa a menos quetodos
los 10de laGetItemLos eventos se limitan.

LaTableName dimension returns the


ReadThrottleEventspara la tabla, pero no
para ningún índice secundario global. Para
verReadThrottleEventspara un índice secundario global,
debe especificarTableNameyGlobalSecondaryIndex.

Unidades:Count

Dimensiones: TableName, GlobalSecondaryIndexName

Estadísticas válidas:

• SampleCount
• Sum

ReplicationLatency (Esta métrica es para tablas globales de DynamoDB.) :


el tiempo transcurrido entre la aparición de un elemento
actualizado en el flujo de DynamoDB para una tabla de
réplica y la aparición de ese elemento en otra réplica de la
tabla global.

Unidades:Milliseconds

Dimensiones: TableName, ReceivingRegion

Estadísticas válidas:

• Average
• Minimum
• Maximum

Versión de API 2012-08-10


953
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

ReturnedBytes El número de bytes devueltos porGetRecordsOperaciones


de (Amazon DynamoDB Streams) durante el periodo de
tiempo especificado.

Unidades:Bytes

Dimensiones: Operation, StreamLabel, TableName

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

ReturnedItemCount El número de elementos devueltos


porQuery,ScanorExecuteStatementOperaciones (select)
durante el periodo de tiempo especificado.

El número de elementosRetornedno es necesariamente


igual que el número de elementos que se evaluaron.
Por ejemplo, suponga que solicitó unScanen una tabla
o un índice que tenía 100 elementos, pero especificó
unFilterExpressionque redujo los resultados de
modo que sólo se devolvieron 15 artículos. En este caso,
la respuesta deScancontendría unScanCountde 100 y
aCountde 15 artículos devueltos.

Unidades:Count

Dimensiones: TableName, Operation

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

Versión de API 2012-08-10


954
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

ReturnedRecordsCount El número de registros de flujo devueltos


porGetRecordsOperaciones de (Amazon DynamoDB
Streams) durante el periodo de tiempo especificado.

Unidades:Count

Dimensiones: Operation, StreamLabel, TableName

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount
• Sum

SuccessfulRequestLatency Solicitudes realizadas correctamente a DynamoDB


o Amazon DynamoDB durante el periodo de tiempo
especificado.SuccessfulRequestLatencypuede
proporcionar dos tipos distintos de información:

• El tiempo transcurrido para las solicitudes correctas


(Minimum,Maximum,Sum, o bienAverage).
• El número de solicitudes realizadas correctamente
(SampleCount).

SuccessfulRequestLatencyrefleja la actividad solo dentro


de DynamoDB o Amazon DynamoDB Streams y no tiene en
cuenta la latencia de la red ni la actividad del cliente.

Unidades:Milliseconds

Dimensiones: TableName, Operation

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount

SystemErrors Las solicitudes a DynamoDB o Amazon DynamoDB Streams


que generan un código de estado HTTP 500 durante el
período de tiempo especificado. Un HTTP 500 normalmente
indica un error de servicio interno.

Unidades:Count

Dimensiones: TableName, Operation

Estadísticas válidas:

• Sum
• SampleCount

Versión de API 2012-08-10


955
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

TimeToLiveDeletedItemCount Número de elementos eliminados por Tiempo de vida (TTTL)


durante el periodo de tiempo especificado. Esta métrica le
ayuda a monitorizar la tasa de eliminaciones de TTTL en la
tabla.

Unidades:Count

Dimensiones: TableName

Estadísticas válidas:

• Sum

ThrottledPutRecordCount El número de registros que no se replicaron en el flujo de


datos de Kinesis debido a la capacidad insuficiente de Kinesis
Data Stream.

Unidades:Count

Dimensiones: TableName, DelegatedOperation

Estadísticas válidas:

• Minimum
• Maximum
• Average
• SampleCount

Versión de API 2012-08-10


956
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

ThrottledRequests Solicitudes a DynamoDB que superen los límites de


rendimiento aprovisionado en un recurso (como una tabla o
un índice).

ThrottledRequestsse incrementa en uno si algún


evento de la solicitud supera el límite de desempeño
aprovisionado. Por ejemplo, si actualiza un elemento de
una tabla con índices secundarios globales, hay varios
eventos: una escritura en la tabla y una escritura en cada
índice. Si uno o más de estos eventos están limitados,
entoncesThrottledRequestsse incrementa en uno.
Note

En una solicitud por lotes


(BatchGetItemorBatchWriteItem),ThrottledRequestssólo
se incrementa sicadaen el lote está limitado.
Si se restringe cualquier solicitud individual dentro
del lote, se incrementa una de las siguientes
métricas:

• ReadThrottleEvents— Para
unGetItemevento deBatchGetItem.
• WriteThrottleEvents— Para
unPutItemorDeleteItemevento
deBatchWriteItem.

Para saber a qué evento de la solicitud se


le está imponiendo la limitación controlada,
compareThrottledRequestsconReadThrottleEventsyWriteThrottl
la tabla y sus índices.
Note

Una solicitud restringida dará como resultado un


código de estado HTTP 400. Todos estos eventos
se reflejan en elThrottledRequests, pero no en
elUserErrorsMétrica de.

Unidades:Count

Dimensiones: TableName, Operation

Estadísticas válidas:

• Sum
• SampleCount

Versión de API 2012-08-10


957
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

TransactionConflict Solicitudes de nivel de artículo rechazadas debido a conflictos


transaccionales entre solicitudes simultáneas en los mismos
elementos. Para obtener más información, consulteGestión
de conflictos de transacciones en DynamoDB.

Unidades:Count

Dimensiones: TableName

Estadísticas válidas:

• Sum— El número de solicitudes de nivel de artículo


rechazadas debido a conflictos de transacciones.
Note

Si varias solicitudes de nivel de


elemento dentro de una llamada
aTransactWriteItemsorTransactGetItemsfueron
rechazadas,Sumse incrementa en uno para
cada nivel de elementoPut,Update,Delete, o
bienGetrequest.
• SampleCount— El número de solicitudes rechazadas
debido a conflictos de transacciones.
Note

Si varias solicitudes de nivel de


elemento dentro de una llamada
aTransactWriteItemsorTransactGetItemsson
rechazados,SampleCountSolo se incrementa en
uno.
• Min— El número mínimo de solicitudes de nivel
de elemento rechazadas dentro de una llamada
aTransactWriteItems,TransactGetItems,PutItem,UpdateItem,
o bienDeleteItem.
• Max— El número máximo de solicitudes de nivel
de elemento rechazadas dentro de una llamada
aTransactWriteItems,TransactGetItems,PutItem,UpdateItem,
o bienDeleteItem.
• Average— El número medio de solicitudes de nivel
de elemento rechazadas dentro de una llamada
aTransactWriteItems,TransactGetItems,PutItem,UpdateItem,
o bienDeleteItem.

Versión de API 2012-08-10


958
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

UserErrors Solicitudes a DynamoDB o Amazon DynamoDB Streams


que generan un código de estado HTTP 400 durante el
período de tiempo especificado. Un HTTP 400 normalmente
indica un error del lado del cliente, como una combinación
de parámetros no válida, un intento de actualizar una tabla
inexistente o una firma de solicitud incorrecta.

Todos estos eventos se reflejan en elUserErrors, excepto


por lo siguiente:

• ProvisionedThroughputExceededException— Consulte
la.ThrottledRequestsmétrica en esta sección.
• ConditionalCheckFailedException— Consulte
la.ConditionalCheckFailedRequestsmétrica en esta
sección.

UserErrorsrepresenta el agregado de errores HTTP 400


para las solicitudes de DynamoDB o Amazon DynamoDB
Streams para el actualAWSRegión y la actualAWSaccount.

Unidades:Count

Estadísticas válidas:

• Sum
• SampleCount

Versión de API 2012-08-10


959
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Métrica Descripción

WriteThrottleEvents Solicitudes a DynamoDB que superen las unidades de


capacidad de escritura aprovisionadas para una tabla o un
índice secundario global.

Una sola solicitud puede dar lugar a múltiples eventos.


Por ejemplo, unPutItemen una tabla con tres índices
secundarios globales daría como resultado cuatro eventos:
la escritura de la tabla y cada una de las tres escrituras
de índice. Para cada evento,WriteThrottleEventsse
incrementa en una si ese evento está limitado. Para
un soloPutItem, si alguno de los eventos está
limitado,ThrottledRequestsTambién se incrementa en
uno. ParaBatchWriteItem, elThrottledRequestsmétrica
para toda laBatchWriteItemno se incrementa a menos que
todos losPutItemorDeleteItemLos eventos se limitan.

LaTableName dimension returns the


WriteThrottleEventspara la tabla, pero
no para ningún índice secundario global. Para
verWriteThrottleEventspara un índice secundario global,
debe especificarTableNameyGlobalSecondaryIndex.

Unidades:Count

Dimensiones: TableName, GlobalSecondaryIndexName

Estadísticas válidas:

• Sum
• SampleCount

Dimensiones para métricas de DynamoDB

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:

• Cambie la captura de datos para Kinesis Data Streams.

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

Versión de API 2012-08-10


960
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Dimensión Descripción
• GetItem
• BatchGetItem
• Scan
• Query
• BatchWriteItem
• TransactWriteItems
• TransactGetItems
• ExecuteTransaction
• BatchExecuteStatement
• ExecuteStatement

Además, puede limitar los datos a la siguiente operación de Amazon


DynamoDB Streams:

• GetRecords

OperationType Esta dimensión limita los datos a uno de los siguientes tipos de
operación:

• Read
• Write

Esta dimensión se emite


paraExecuteTransactionyBatchExecuteStatementsolicitudes.

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

Esta dimensión se emite para elExecuteStatement.

ReceivingRegion Esta dimensión limita los datos a unAWSregion. Se utiliza con


métricas procedentes de tablas de réplica dentro de una tabla global
de DynamoDB.

StreamLabel Esta dimensión limita los datos a una etiqueta de transmisión


específica. Se utiliza con métricas procedentes de Amazon
DynamoDB StreamsGetRecordsOperaciones.

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.

Versión de API 2012-08-10


961
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

¿Cómo utilizo las métricas de de DynamoDB?


Las métricas mostradas por DynamoDB proporcionan información que puede analizar de diferentes
maneras. En la siguiente lista se indican algunos usos frecuentes de las métricas. Se trata de sugerencias
que puede usar como punto de partida y no de una lista completa.

¿Cómo...? Métricas relevantes

How can I monitor the Puede monitorizarTimeToLiveDeletedItemCountDurante


rate of TTL deletions on el periodo de tiempo especificado, para realizar el seguimiento
my table? de la tasa de eliminaciones de TTTL en la tabla. Para obtener
un ejemplo de una aplicación sin servidor que utiliza la
herramientaTimeToLiveDeletedItemCountmétrica,
consulteArchivar automáticamente elementos en S3 usando
DynamoDB Time to Live (TTTL) conAWS Lambday Amazon Kinesis
Data Firehose.

How can I determine how Puede monitorizar ConsumedReadCapacityUnits o


much of my provisioned ConsumedWriteCapacityUnits durante el periodo de tiempo
throughput is being especificado para realizar el seguimiento de la cantidad de
used? desempeño provisionado que se está usando.

How can I determine ThrottledRequests se incrementa en uno si algún evento


which requests exceed de la solicitud supera la cuota de rendimiento aprovisionada.
the provisioned A continuación, para saber a qué evento de la solicitud se
throughput quotas of a le está imponiendo la limitación controlada, compare las
table? métricas ThrottledRequests con ReadThrottleEvents y
WriteThrottleEvents para la tabla y sus índices.

How can I determine Puede monitorizarSystemErrorsPara determinar si alguna


if any system errors solicitud ha dado lugar a un código HTTP 500 (error del servidor).
occurred? Normalmente, esta métrica debe ser igual a cero. si no lo es, es
conveniente investigar por qué.
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.

Creación de alarmas de CloudWatch para monitorear DynamoDB


Puede crear una alarma de CloudWatch que envíe un mensaje de Amazon SNS cuando la alarma cambie
de estado. Una alarma vigila una única métrica durante el periodo especificado y realiza una o varias
acciones en función del valor de la métrica relativo a 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 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 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.
Note

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.

Versión de API 2012-08-10


962
Amazon DynamoDB Guía para desarrolladores
Monitorización con Amazon CloudWatch

Para obtener una lista de las métricas admitidas y sus dimensiones requeridas en DynamoDB,
consulteDimensiones y métricas de DynamoDB (p. 940).

¿Cómo puedo recibir una notificación antes de haber consumido toda la


capacidad de lectura?
1. Cree un tema sobre Amazon SNSarn:aws:sns:us-east-1:123456789012:capacity-alarm.

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.

aws cloudwatch put-metric-alarm \


--alarm-name ReadCapacityUnitsLimitAlarm \
--alarm-description "Alarm when read capacity reaches 80% of my provisioned read
capacity" \
--namespace AWS/DynamoDB \
--metric-name ConsumedReadCapacityUnits \
--dimensions Name=TableName,Value=myTable \
--statistic Sum \
--threshold 240 \
--comparison-operator GreaterThanOrEqualToThreshold \
--period 60 \
--evaluation-periods 1 \
--alarm-actions arn:aws:sns:us-east-1:123456789012:capacity-alarm

3. Pruebe la alarma.

aws cloudwatch set-alarm-state --alarm-name ReadCapacityUnitsLimitAlarm --state-reason


"initializing" --state-value OK

aws cloudwatch set-alarm-state --alarm-name ReadCapacityUnitsLimitAlarm --state-reason


"initializing" --state-value ALARM

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.

aws cloudwatch put-metric-alarm \


--alarm-name RequestsExceedingThroughputAlarm\
--alarm-description "Alarm when my requests are exceeding provisioned throughput
quotas of a table" \
--namespace AWS/DynamoDB \

Versión de API 2012-08-10


963
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

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

aws cloudwatch set-alarm-state --alarm-name RequestsExceedingThroughputAlarm --state-


reason "initializing" --state-value OK

aws cloudwatch set-alarm-state --alarm-name RequestsExceedingThroughputAlarm --state-


reason "initializing" --state-value ALARM

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

aws cloudwatch put-metric-alarm \


--alarm-name SystemErrorsAlarm \
--alarm-description "Alarm when system errors occur" \
--namespace AWS/DynamoDB \
--metric-name SystemErrors \
--dimensions Name=TableName,Value=myTable Name=Operation,Value=aDynamoDBOperation \
--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.

aws cloudwatch set-alarm-state --alarm-name SystemErrorsAlarm --state-reason


"initializing" --state-value OK

aws cloudwatch set-alarm-state --alarm-name SystemErrorsAlarm --state-reason


"initializing" --state-value ALARM

Registro de operaciones de DynamoDB


utilizandoAWS CloudTrail
DynamoDB está integrado conAWS CloudTrail, un servicio que proporciona un registro de las medidas
adoptadas por un usuario, un rol o unAWSServicio en DynamoDB. CloudTrail captura como eventos todas
las llamadas a la API de DynamoDB. Las llamadas capturadas incluyen las llamadas desde la consola de

Versión de API 2012-08-10


964
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

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.

Información de DynamoDB en CloudTrail


CloudTrail se habilita en su cuenta de AWS cuando la crea. Cuando se produce una actividad de
eventos compatible en DynamoDB, dicha actividad se registra en un evento de CloudTrail junto con
otrosAWSeventos de servicioHistorial de eventos. Puede ver, buscar y descargar los últimos eventos de
la cuenta de AWS. Para obtener más información, consulte Visualización de eventos con el historial de
CloudTrail Event.

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:

• Introducción a la creación de registros de seguimiento


• Consulte Servicios e integraciones compatibles con CloudTrail.
• Configuración de notificaciones de Amazon SNS para CloudTrail
• Recibir archivos de registro de CloudTrail de varias regiones y Recepción de archivos de registro de
CloudTrail de varias cuentas

Eventos de Plano de control en CloudTrail


Las siguientes acciones de la API se registran de forma predeterminada como eventos en archivos de
CloudTrail:

Amazon DynamoDB

• CreateBackup
• CreateGlobalTable
• CreateTable
• DeleteBackup
• DeleteTable
• DescribeBackup
• DescribeContinuousBackups
• DescribeGlobalTable

Versión de API 2012-08-10


965
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

• DescribeLimits
• DescribeTable
• DescribeTimeToLive
• ListBackups
• ListTables
• ListTagsOfResource
• ListGlobalTables
• RestoreTableFromBackup
• RestoreTableToPointInTime
• TagResource
• UntagResource
• UpdateGlobalTable
• UpdateTable
• UpdateTimeToLive
• DescribeReservedCapacity
• DescribeReservedCapacityOfferings
• DescribeScalableTargets
• RegisterScalableTarget
• PurchaseReservedCapacityOfferings

DynamoDB Streams

• DescribeStream
• ListStreams

DynamoDB Accelerator (DAX)

• CreateCluster
• CreateParameterGroup
• CreateSubnetGroup
• DecreaseReplicationFactor
• DeleteCluster
• DeleteParameterGroup
• DeleteSubnetGroup
• DescribeClusters
• DescribeDefaultParameters
• DescribeEvents
• DescribeParameterGroups
• DescribeParameters
• DescribeSubnetGroups
• IncreaseReplicationFactor
• ListTags
• RebootNode
• TagResource
• UntagResource

Versión de API 2012-08-10


966
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

• UpdateCluster
• UpdateParameterGroup
• UpdateSubnetGroup

Eventos de plano de datos DynamoDB en CloudTrail


Para habilitar el registro de las siguientes acciones de API en los archivos de 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.

Amazon DynamoDB

• BatchExecuteStatement
• BatchGetItem
• BatchWriteItem
• DeleteItem
• ExecuteStatement
• ExecuteTransaction
• GetItem
• PutItem
• Consulta
• Examen
• TransactGetItems
• TransactWriteItems
• UpdateItem

Note

DynamoDB Trail no registra las acciones del plano de datos de CloudTrail

DynamoDB Streams

• GetRecords
• GetShardIterator

Descripción de las entradas de archivos de registro de Dynamo


Un registro de seguimiento es una configuración que permite la entrega de eventos como archivos de
registro en un bucket de Amazon S3 que especifique. Los archivos log de CloudTrail pueden contener
una o varias entradas de log. Un evento representa una única solicitud de cualquier origen e incluye
información acerca de la acción solicitada, la fecha y la hora de la acción, los parámetros de la solicitud,
etcétera.

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.

Versión de API 2012-08-10


967
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

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.

Para obtener más información, consulte el Elemento userIdentity de CloudTrail.

Los siguientes ejemplos demuestran los registros de CloudTrail de estos tipos de eventos:

Amazon DynamoDB

• UpdateTable (p. 968)


• DeleteTable (p. 969)
• CreateCluster (p. 970)
• PutItem(éxito) (p. 971)
• UpdateItem(sin éxito) (p. 972)
• TransactWriteItems(éxito) (p. 973)
• TransactWriteItems(conTransactionCanceledException) (p. 975)
• ExecuteStatement (p. 977)
• BatchExecuteStatement (p. 978)

DynamoDB Streams

• GetRecords (p. 979)

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": {

Versión de API 2012-08-10


968
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

"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",

Versión de API 2012-08-10


969
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

"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": {

Versión de API 2012-08-10


970
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

"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": {

Versión de API 2012-08-10


971
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

"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": {

Versión de API 2012-08-10


972
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

"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",

Versión de API 2012-08-10


973
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

"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": {

Versión de API 2012-08-10


974
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

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

Versión de API 2012-08-10


975
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

}
}
},
"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"

Versión de API 2012-08-10


976
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

},
"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",

Versión de API 2012-08-10


977
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

"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'"
},
{

Versión de API 2012-08-10


978
Amazon DynamoDB Guía para desarrolladores
Registro de operaciones de
DynamoDB utilizandoAWS CloudTrail

"statement": "INSERT INTO Music VALUE {'Artist' : ***(Redacted),


'SongTitle' : ***(Redacted), 'Album' : ***(Redacted)}"
}
]
},
"responseElements": null,
"requestID": "23PE7ED291UD65P9SMS6TISNVBVV4KQNSO5AEMVJF66Q9ASUAAJG",
"eventID": "f863f966-b741-4c36-b15e-f867e829035a",
"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"
}
]
}

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

Versión de API 2012-08-10


979
Amazon DynamoDB Guía para desarrolladores
Registro y monitorización en DAX

+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"
}
]
}

Registro y monitorización en DynamoDB


Accelerator
El monitoreo es una parte importante del mantenimiento de la fiabilidad, la disponibilidad y el rendimiento
del Acelerador de Amazon DynamoDB (DAX) y suAWSSoluciones de. Debe recopilar datos de monitoreo
de todas las partes de suAWSPara que pueda depurar con mayor facilidad un error de múltiples puntos, si
ocurre alguno.

Para obtener más información acerca del registro y la monitorización en DAX, consulteMonitorización de
DAX (p. 797).

Análisis del acceso a datos con CloudWatch


Contributor Insights for DynamoDB
Amazon CloudWatch Contributor Insights for Amazon DynamoDB es una herramienta de diagnóstico
que permite identificar de un vistazo las claves de acceso más frecuente y sometidas a más restricciones
controladas de una tabla o índice. Esta herramienta utiliza CloudWatch Contributor Insights.

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.

Versión de API 2012-08-10


980
Amazon DynamoDB Guía para desarrolladores
Cómo funciona

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)

Información de CloudWatch Contributor Insights for


DynamoDB: Cómo funciona
Amazon DynamoDB se integra conInformación de Amazon CloudWatch Contributor InsightsPara
proporcionar información sobre los elementos a los que más se accede y sometidos a más limitaciones
controladas en una tabla o un índice secundario global. DynamoDB le entrega esta información a través de
CloudWatch Colabortor InsightsReglas de,reportsy gráficos de los datos del informe.

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.

En las secciones siguientes se describen los conceptos y comportamientos básicos de CloudWatch


Contributor Insights for DynamoDB.

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)

Reglas de CloudWatch Contributor Insights for DynamoDB


Cuando se habilita CloudWatch Contributor Insights for DynamoDB en una tabla o un índice secundario
global, DynamoDB crea automáticamente las siguientes reglas:

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

Formato de nombre de regla de:DynamoDBContributorInsights-PKC-[resource_name]-


[creationtimestamp]
• La mayoría de las teclas restringidas (clave de partición)Identifica las claves de partición de los
elementos sometidos a más limitaciones controladas de la tabla o del índice secundario global.

Formato de nombre de regla de:DynamoDBContributorInsights-PKT-[resource_name]-


[creationtimestamp]

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.

Formato de nombre de regla de:DynamoDBContributorInsights-SKC-[resource_name]-


[creationtimestamp]
• La mayoría de las teclas restringidas (claves de partición y ordenación)Identifica las claves de partición
y ordenación de los elementos sometidos a más limitaciones controladas de la tabla o del índice
secundario global.

Versión de API 2012-08-10


981
Amazon DynamoDB Guía para desarrolladores
Cómo funciona

Formato de nombre de regla de:DynamoDBContributorInsights-SKT-[resource_name]-


[creationtimestamp]

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.

Descripción de los gráficos de CloudWatch Contributor Insights


for DynamoDB
CloudWatch Contributor Insights for DynamoDB muestra dos tipos de gráficos en las consolas de
DynamoDB y CloudWatch: Most Accessed Items (Elementos a los que más se accede)yMost Throttled
Items (Elementos sometidos a más limitaciones controladas).

Most Accessed Items (Elementos a los que más se accede)


Use este gráfico para identificar los elementos a los que se accede con más frecuencia en la tabla o el
índice secundario global. El gráfico muestra los valores de ConsumedThroughputUnits en el eje Y y
el tiempo en el eje X. Cada una de las N claves principales se muestra con su propio color y la leyenda
aparece debajo del eje X.

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:

• Aprovisionado —(3 unidades de capacidad de escritura consumida) + unidades de capacidad de lectura


consumidas
• Bajo demanda —(3 unidades de solicitud de escritura) + unidades de solicitud de lectura

En la consola de DynamoDB, cada punto de datos del gráfico representa el máximo


deConsumedThroughputUnitsdurante un período de 1 minuto. Por ejemplo, un valor de 180 000
ConsumedThroughputUnits en el gráfico indica que se ha accedido continuamente a ese elemento al
máximo rendimiento por elemento de 1000 unidades de solicitud de escritura o 3000 unidades de solicitud
de lectura a lo largo de 60 segundos durante ese periodo de un minuto (3000 x 60 segundos). Dicho de
otro modo, los valores del gráfico representan el minuto con el máximo tráfico de cada periodo de un
minuto. Puede cambiar la granularidad de tiempo delConsumedThroughputUnits(por ejemplo, para ver
métricas de 5 minutos en lugar de 1 minuto) en la consola de CloudWatch.

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

Versión de API 2012-08-10


982
Amazon DynamoDB Guía para desarrolladores
Cómo funciona

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.

Most Throttled Items (Elementos sometidos a más limitaciones controladas)


Use este gráfico para identificar los elementos sometidos a más limitaciones controladas en la tabla o el
índice secundario global. El gráfico muestra los valores de ThrottleCount en el eje Y y el tiempo en el
eje X. Cada una de las N claves principales se muestra con su propio color y la leyenda aparece debajo del
eje X.

DynamoDB mide la frecuencia de las limitaciones controladas mediante ThrottleCount, que es la


cantidad de excepciones ProvisionedThroughputExceededException y ThrottlingException y
de errores RequestLimitExceeded.

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.

Versión de API 2012-08-10


983
Amazon DynamoDB Guía para desarrolladores
Cómo funciona

Interacciones con otras características de DynamoDB


En las siguientes secciones se describe cómo CloudWatch Contributor Insights for DynamoDB se
comporta e interactúa con otras características de DynamoDB.

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.

DynamoDB Accelerator (DAX)


Las respuestas de CloudWatch Contributor Insights for DynamoDB no muestran respuestas de caché DAX.
Sólo muestra respuestas para acceder a una tabla o a un índice secundario global.

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.

Control de acceso detallado


CloudWatch Contributor Insights for DynamoDB no funciona de manera diferente para las tablas con
control de acceso detallado (FGAC). En otras palabras, cualquier usuario que tenga los permisos
de CloudWatch adecuados puede ver las claves principales protegidas por FGAC en los gráficos de
CloudWatch Contributor Insights.

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.

Facturación de CloudWatch Contributor Insights for DynamoDB


Los cargos de CloudWatch Contributor Insights for DynamoDBCloudWatchLa sección de su factura
mensual. Estos cargos se calculan en función del número de eventos de DynamoDB que se procesan.
Para las tablas y los índices secundarios globales en los que se ha habilitado CloudWatch Contributor
Insights for DynamoDB, cada elemento escrito o leído a través de unPlano de datosrepresenta un evento.

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

Versión de API 2012-08-10


984
Amazon DynamoDB Guía para desarrolladores
Introducción

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

A diferencia de otras funciones de DynamoDB, CloudWatch Contributor Insights for DynamoDBNovarían


en función de lo siguiente:

• El modo de capacidad (aprovisionada frente a bajo demanda)


• Si realiza solicitudes de lectura o escritura
• El tamaño (KB) de los elementos leídos o escritos

Introducción a CloudWatch Contributor Insights for


DynamoDB
En esta sección se describe cómo utilizar Amazon CloudWatch Contributor Insights con la consola de
Amazon DynamoDB o laAWS Command Line Interface(AWS CLI).

En los ejemplos siguientes, se usa la tabla de DynamoDB definida en elIntroducción a DynamoDB"Hello,


World!"

Temas
• Uso de Contributor Insights (consola) (p. 985)
• Uso de Contributor Insights (AWS CLI) (p. 988)

Uso de Contributor Insights (consola)


1. Inicie sesión en la.AWS Management Consoley abra la consola de DynamoDB enhttps://
console.aws.amazon.com/dynamodb/.
2. En el panel de navegación del lado izquierdo de la consola, elija Tables (Tablas).
3. Elija la tabla Music.
4. Elija la pestaña Contributor Insights.
5. Elija Manage Contributor Insights (Administrar Contributor Insights).

Versión de API 2012-08-10


985
Amazon DynamoDB Guía para desarrolladores
Introducción

6. En el cuadro de diálogo Manage Contributor Insights (Administrar Contributor Insights), en Contributor


Insights Status (Estado de Contributor Insights), elija Enabled (Habilitado) para la tabla base Music
y para el índice secundario global AlbumTitle-index. A continuación, seleccione Confirm
(Confirmar).

Si la operación da error, consulteDescribeContributorInsights FailureExceptionen laReferencia de la


API de Amazon DynamoDBpor posibles razones.
7. Elija View in DynamoDB (Ver en DynamoDB).

8. Aparecerán los gráficos de Contributor Insights visibles en la pestaña Contributor Insights para la tabla
Music.

Versión de API 2012-08-10


986
Amazon DynamoDB Guía para desarrolladores
Introducción

Creación de alarmas de CloudWatch


Siga estos pasos para crear una alarma de CloudWatch y recibir una notificación cuando cualquier clave
de partición consume más de 50 000 ConsumedThroughPutUnits.

1. Inicie sesión en la.AWS Management Consoley abra la consola de CloudWatch enhttps://


console.aws.amazon.com/cloudwatch/
2. En el panel de navegación del lado izquierdo de la consola, seleccione Contributor Insights.
3. Elija el iconoDynamoDBContributorInsights-PKC-MusicRegla de.
4. Seleccione el menú desplegable Acciones.
5. Elija View in metrics (Ver en métricas).
6. Seleccione Valor máximo de colaborador.
Note

Solo Max Contributor Value y Maximum producen estadísticas útiles. Las demás
estadísticas de esta lista no devuelven valores significativos.

7. En la columna Acciones seleccione Crear alarma.

Versión de API 2012-08-10


987
Amazon DynamoDB Guía para desarrolladores
Introducción

8. Introduzca un valor de 50000thresholdy elijaSiguiente.

9. ConsulteUso de alarmas de Amazon CloudWatchPara obtener información sobre cómo configurar la


notificación de la alarma.

Uso de Contributor Insights (AWS CLI)


1. Habilitar CloudWatch Contributor Insights for DynamoDBMusicmesa base.

aws dynamodb update-contributor-insights --table-name Music --contributor-insights-


action=ENABLE

2. Habilite Contributor Insights for DynamoDB enAlbumTitle-indexíndice secundario global.

aws dynamodb update-contributor-insights --table-name Music --index-name AlbumTitle-


index --contributor-insights-action=ENABLE

3. Obtenga el estado y las reglas de la tabla Music y todos sus índices.

aws dynamodb describe-contributor-insights --table-name Music

Versión de API 2012-08-10


988
Amazon DynamoDB Guía para desarrolladores
Uso de IAM

4. Deshabilite CloudWatch Contributor Insights for DynamoDBAlbumTitle-indexíndice secundario


global.

aws dynamodb update-contributor-insights --table-name Music --index-name AlbumTitle-


index --contributor-insights-action=DISABLE

5. Obtenga el estado de la tabla Music y todos sus índices.

aws dynamodb list-contributor-insights --table-name Music

Uso de IAM con CloudWatch Contributor Insights for


DynamoDB
La primera vez que habilita Amazon CloudWatch Contributor Insights for Amazon DynamoDB,
DynamoDB crea automáticamente unAWS Identity and Access Management(IAM) para usted. Esta
función,AWSServiceRoleForDynamoDBCloudWatchContributorInsights, permite que DynamoDB
administre las reglas de CloudWatch Contributor Insights por usted. No elimine este rol vinculado a un
servicio. Si lo elimina, todas las reglas administradas dejarán de limpiarse cuando se elimine la tabla o el
índice secundario global.

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.

Los siguientes permisos son necesarios:

• Para habilitar o deshabilitar CloudWatch Contributor Insights for DynamoDB, debe


tenerdynamodb:UpdateContributorInsightsen la tabla o el índice.
• Para ver los gráficos de CloudWatch Contributor Insights for DynamoDB, debe tener el permiso
cloudwatch:GetInsightRuleReport.
• Para describir CloudWatch Contributor Insights for DynamoDB para una determinada tabla o índice de
DynamoDB, debe tenerdynamodb:DescribeContributorInsightsPermiso.
• Para enumerar los estados de CloudWatch Contributor Insights for DynamoDB para cada tabla e índice
secundario global, debe tener el permiso dynamodb:ListContributorInsights.

Ejemplo: Habilitar o deshabilitar CloudWatch Contributor Insights


for DynamoDB
La siguiente política de IAM concede permisos para habilitar o deshabilitar CloudWatch Contributor Insights
for DynamoDB.

{
"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"}}
},
{

Versión de API 2012-08-10


989
Amazon DynamoDB Guía para desarrolladores
Uso de IAM

"Effect": "Allow",
"Action": [
"dynamodb:UpdateContributorInsights"
],
"Resource": "arn:aws:dynamodb:*:*:table/*"
}
]
}

Ejemplo: Recuperar un informe de reglas de CloudWatch


Contributor In
La siguiente política de IAM concede permisos para recuperar un informe de reglas de CloudWatch
Contributor Insights.

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:GetInsightRuleReport"
],
"Resource": "arn:aws:cloudwatch:*:*:insight-rule/DynamoDBContributorInsights*"
}
]
}

Ejemplo: Aplicar selectivamente permisos de CloudWatch


Contributor Insights for DynamoDB basados en recursos
La siguiente política de IAM concede permisos para permitir
elListContributorInsightsyDescribeContributorInsightsacciones y niega
elUpdateContributorInsightsPara un índice secundario global específico.

{
"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"
}
]
}

Versión de API 2012-08-10


990
Amazon DynamoDB Guía para desarrolladores
Uso de IAM

Uso de roles vinculados a servicios para CloudWatch Contributor


Insights for DynamoDB
Utiliza CloudWatch Contributor Insights for DynamoDBAWS 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 CloudWatch Contributor Insights for DynamoDB. Los roles vinculados a servicios están
predefinidos por CloudWatch Contributor Insights for DynamoDB e incluyen todos los permisos que el
servicio requiere para llamar a otrosAWSServicios de en su nombre.

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.

Permisos de roles vinculados a servicios para CloudWatch Contributor Insights for


DynamoDB
Descripción de CloudWatch Contributor Insights for
DynamoDBAWSServiceRoleforDynamodbCloudWatchContributorInsights. El propósito de la función
vinculada a servicios es permitir que Amazon DynamoDB administre las reglas de Amazon CloudWatch
Colabortor Insights creadas para tablas de DynamoDB e índices secundarios globales, en su nombre.

La función vinculada al servicio AWSServiceRoleForDynamoDBCloudWatchContributorInsights


confía en los siguientes servicios para asumir la funció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:

• Acción: Create and manage Insight Rules en DynamoDBContributorInsights

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 CloudWatch Contributor Insights


for DynamoDB
No necesita crear manualmente un rol vinculado a un servicio. Cuando habilita Insights de Colaborador en
elAWS Management Console, elAWS CLI, o elAWSCloudWatch Contributor Insights for 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 Contributor Insights, CloudWatch Contributor Insights for
DynamoDB crea de nuevo el rol vinculado a servicios.

Versión de API 2012-08-10


991
Amazon DynamoDB Guía para desarrolladores
Uso de IAM

Edición de un rol vinculado a un servicio para CloudWatch Contributor Insights for


DynamoDB
Información de CloudWatch Contributor Insights for DynamoDB no le permite editar
elAWSServiceRoleForDynamoDBCloudWatchContributorInsightsServicio 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 CloudWatch Contributor


Insights for DynamoDB
No es necesario eliminar manualmente el rol de
AWSServiceRoleForDynamoDBCloudWatchContributorInsights. Cuando deshabilita Insights
de Colaborador en elAWS Management Console, elAWS CLI, o elAWSAPI de CloudWatch Contributor
Insights for DynamoDB

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.

Para eliminar manualmente el rol vinculado a un servicio mediante IAM

Utilice la consola de IAM,AWS CLI, o elAWSAPI para eliminar


laAWSServiceRoleForDynamoDBCloudWatchContributorInsightsServicio Para obtener más
información, consulte Eliminación de un rol vinculado a servicios en la Guía del usuario de IAM.

Versión de API 2012-08-10


992
Amazon DynamoDB Guía para desarrolladores

Prácticas recomendadas para


el diseño y la arquitectura con
DynamoDB
Utilice esta sección para encontrar con rapidez recomendaciones que le permitan maximizar el rendimiento
y minimizar sus costos al usar Amazon DynamoDB.

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)

Versión de API 2012-08-10


993
Amazon DynamoDB Guía para desarrolladores
Diseño NoSQL

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

Diseño NoSQL para DynamoDB


Los sistemas de bases de datos NoSQL como Amazon DynamoDB utilizan modelos alternativos de
administración de datos, como los pares clave-valor o el almacenamiento de documentos. Al pasar de un
sistema de administración de bases de datos relacionales a un sistema de bases de datos NoSQL como
DynamoDB, es importante entender las principales diferencias y los enfoques de diseño específicos.

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)

Diferencias entre el diseño de datos relacionales y


NoSQL
Los sistemas de bases de datos relacionales (RDBMS) y las bases de datos NoSQL tienen diferentes
ventajas y desventajas:

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

Versión de API 2012-08-10


994
Amazon DynamoDB Guía para desarrolladores
Dos conceptos clave

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

Dos conceptos clave del diseño NoSQL


El diseño NoSQL requiere un modo de pensar distinto al diseño de RDBMS. En un sistema RDBMS, puede
empezar a crear un modelo de datos normalizados sin pensar en los patrones de acceso. Posteriormente,
podrá ampliar este modelo cuando surjan nuevos requisitos sobre preguntas y consultas. Puede organizar
cada tipo de datos en su propia tabla.

Cómo es diferente el diseño NoSQL:

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

Aproximación al diseño NoSQL


El primer paso para diseñar la aplicación DynamoDB es identificar los patrones de consulta específicos
que el sistema debe satisfacer.

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

Versión de API 2012-08-10


995
Amazon DynamoDB Guía para desarrolladores
Diseño de claves de partición

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.

Prácticas recomendadas para diseñar y utilizar


claves de partición de forma eficaz
La clave principal que identifica de manera inequívoca cada elemento de una tabla de Amazon DynamoDB
puede ser simple (ser únicamente una clave de partición) o compleja (estar formado por una clave de
partición y una clave de ordenación).

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)

Uso eficaz de la capacidad de ráfagas


DynamoDB proporciona cierta flexibilidad en el provisionamiento del desempeño por particiones, ya que
proporcionaCapacidad de ráfagas. Cuando no se utiliza todo el rendimiento de una partición, DynamoDB
reserva una parte de esa capacidad sin utilizar para más adelanteráfagasde rendimiento para manejar los
picos de uso.

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.

Versión de API 2012-08-10


996
Amazon DynamoDB Guía para desarrolladores
Capacidad de adaptación

Tenga en cuenta que estos detalles sobre la capacidad de ráfagas podrían cambiar en el futuro.

Descripción de la capacidad de adaptación de


DynamoDB
Capacidad de adaptaciónes una función que permite que DynamoDB ejecute cargas de trabajo
desequilibradas de manera indefinida. Minimiza la limitación controlada causada a las excepciones de
rendimiento. También ayuda a reducir los costos, porque permite aprovisionar únicamente la capacidad de
rendimiento que se necesita.

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)

Aumento de la capacidad de rendimiento en particiones de tráfico


intenso
No siempre es posible distribuir uniformemente la actividad de lectura y escritura. Si el acceso a los
datos está desequilibrado, una partición "caliente" podría recibir un volumen mayor de tráfico de lectura y
escritura que otras particiones. En casos extremos, podría llegar a producirse una limitación controlada si
una partición recibe más de 3000 RCU o 1000 WCU.

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.

El siguiente diagrama ilustra el funcionamiento de la capacidad de adaptación. La tabla de ejemplo está


aprovisionada con 400 WCU distribuidas de manera uniforme entre cuatro particiones, lo que permite que
cada una de ellas admita un máximo de 100 WCU por segundo. Cada una de las particiones 1, 2 y 3 recibe
tráfico de escritura de 50 WCU/seg. La partición 4 recibe 150 WCU/seg. Esta partición caliente puede
aceptar tráfico de escritura mientras haya capacidad de ráfagas disponible, pero terminará limitando de
forma controlado el tráfico que supere las 100 WCU/s.

La capacidad de adaptación de DynamoDB responde incrementando la capacidad de la partición 4, de


forma que pueda soportar la carga de trabajo de 150 WCU/s sin que se produzca una limitación limitada.

Versión de API 2012-08-10


997
Amazon DynamoDB Guía para desarrolladores
Distribución de cargas de trabajo

Aislamiento de elementos de acceso frecuente


Si su aplicación dirige un tráfico alto hacia uno o dos elementos de forma desproporcionada, la capacidad
de adaptación volverá a equilibrar sus particiones de manera que los elementos con acceso frecuente
no residan en la misma partición. Este aislamiento de los elementos de acceso frecuente reduce la
probabilidad de que se solicite la limitación controlada debida a que la carga de trabajo supere la cuota de
rendimiento de una única partición.

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

Esta funcionalidad de aislamiento no está disponible para

• Las tablas que tienen un índice secundario local .


• Las tablas que utilizan el modo de capacidad de lectura/escritura aprovisionada que tienen las
secuencias de DynamoDB habilitadas.

Diseñar claves de partición para distribuir la carga de


trabajo uniformemente
La parte formada por la clave de partición de la clave primaria de una tabla determina las particiones
lógicas en las que se almacenan los datos de la tabla. Esto, a su vez, afecta a las particiones físicas
subyacentes. La capacidad de E/S aprovisionada para la tabla se divide uniformemente entre estas
particiones físicas. Por tanto, un diseño de clave de partición que no distribuya las solicitudes de E/S
uniformemente podría crear particiones "calientes" que provoquen una limitación controlada y no utilicen la
capacidad de E/S aprovisionada de forma eficaz.

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.

A continuación, se muestra una comparación de la eficiencia del rendimiento aprovisionado de algunos


esquemas de claves de partición comunes.

Valor de clave de partición Uniformidad

ID de usuario, en caso de que la aplicación tenga Buena


muchos usuarios.

Código de estado, aunque solo hay algunos Mala


códigos de estado posibles.

Fecha de creación del elemento, redondeada al Mala


periodo más próximo (por ejemplo, día, hora o
minuto).

Versión de API 2012-08-10


998
Amazon DynamoDB Guía para desarrolladores
Fragmentación de escritura

Valor de clave de partición Uniformidad

ID de dispositivo, en un caso en que cada Buena


dispositivo obtiene acceso a los datos a intervalos
relativamente similares.

ID del dispositivo, donde, aunque se hace un Mala


seguimiento de muchos dispositivos, uno de ellos
es muchísimo más popular que los demás.

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.

Uso de la fragmentación de escritura para distribuir


cargas de trabajo uniformemente
Una forma de distribuir mejor las escrituras entre un espacio de claves de partición en Amazon DynamoDB
consiste en ampliar el espacio. Esto puede hacerse de diferentes maneras. Puede agregar un número
aleatorio a los valores de clave de partición para distribuir los elementos entre particiones. O puede usar un
número que se calcula en función de algo que esté consultando.

Fragmentación con sufijos aleatorios


Una estrategia para distribuir las cargas de forma más uniforme en un espacio de claves de partición
consiste en añadir un número aleatorio al final de los valores de la clave de partición. De ese modo, las
escrituras se distribuyen aleatoriamente por un espacio mayor.

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.

Versión de API 2012-08-10


999
Amazon DynamoDB Guía para desarrolladores
Carga eficiente de datos

Fragmentación con sufijos calculados


Aplicar una estrategia de aleatorización puede mejorar considerablemente el rendimiento de la escritura.
Sin embargo, dificulta la lectura de un elemento concreto, ya que no es posible saber qué sufijo se utilizó al
escribir el elemento. Para facilitar la lectura de elementos concretos, puede usar una estrategia diferente.
En lugar de utilizar un número aleatorio para distribuir los elementos entre las particiones, puede utilizar un
número que se calculará en función de algo que se quiere consultar.

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

Distribuya la actividad de escritura de manera eficiente


al cargar los datos
Normalmente, cuando se cargan datos de otros orígenes de datos, Amazon DynamoDB particiona los
datos de la tabla en varios servidores. Se obtiene un desempeño mejor si se cargan datos en todos los
servidores asignados de forma simultánea.

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

U1 ... hasta 100

Versión de API 2012-08-10


1000
Amazon DynamoDB Guía para desarrolladores
Diseño de clave de ordenación

UserID MessageID

U2 1

U2 2

U2 ...

U2 ... hasta 200

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.

Prácticas recomendadas sobre el uso de claves de


ordenación para organizar datos
En una tabla de Amazon DynamoDB, la clave principal que identifica de manera inequívoca cada elemento
de la tabla, además de contener una clave de partición, puede contener también una clave de ordenación.

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.

Versión de API 2012-08-10


1001
Amazon DynamoDB Guía para desarrolladores
Control de la versión

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

Uso de claves de ordenación para el control de


versiones
Muchas aplicaciones deben conservar el historial de revisiones de los elementos por motivos de auditoría
o conformidad y para poder recuperar fácilmente la versión más reciente. Existe un patrón de diseño eficaz
que permite hacerlo mediante prefijos de clave de ordenación:

• 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_.

Versión de API 2012-08-10


1002
Amazon DynamoDB Guía para desarrolladores
Índices secundarios

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.

Prácticas recomendadas para utilizar índices


secundarios en DynamoDB
Con frecuencia, los índices secundarios resultan esenciales para admitir los patrones de consulta que
necesita la aplicación. Sin embargo, un uso excesivo o inadecuado de estos índices podría incrementar los
costos y reducir el rendimiento innecesariamente.

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)

Directrices generales sobre los índices secundarios de


DynamoDB
Amazon DynamoDB admite dos tipos de índices secundarios:

• Í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).

Versión de API 2012-08-10


1003
Amazon DynamoDB Guía para desarrolladores
Directrices generales

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)

Utilice los índices eficazmente


Mantenga el menor número de índices posible. No cree índices secundarios en atributos que no consulte
con frecuencia. Los índices que se utilizan pocas veces provocan un aumento del almacenamiento y de los
costos de E/S y no mejoran el rendimiento de la aplicación.

Elija con cautela las proyecciones


Como los índices secundarios consumen almacenamiento y rendimiento aprovisionado, es importante que
su tamaño sea lo menor posible. Además, cuanto menor sea el índice, mayor será el beneficio en términos
de rendimiento en comparación con una consulta que abarque toda la tabla. Si las consultas suelen
devolver tan solo un reducido subconjunto de atributos y el tamaño total de estos atributos es mucho
menor que la totalidad del elemento, proyecte solamente aquellos atributos que solicite habitualmente.

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.

Optimice las consultas frecuentes para evitar las recuperaciones


Para acelerar al máximo las consultas con la mínima latencia posible, proyecte todos los atributos que crea
que se van a devolver en esas consultas. En particular, si consulta un índice secundario local para buscar

Versión de API 2012-08-10


1004
Amazon DynamoDB Guía para desarrolladores
Índices dispersos

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

Tenga en cuenta los límites de tamaño de la colección de


elementos al crear índices secundarios locales
Una colección de elementos contiene todos los elementos de una tabla y los índices secundarios globales
que tienen la misma clave de partición. Ninguna colección de elementos puede superar los 10 GB, así que
es posible que se agote el espacio para un determinado valor de clave de partición.

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

Saque partido de los índices dispersos


Para cualquier elemento de una tabla, DynamoDB escribe una entrada de índice correspondienteSólo si el
valor de la clave de ordenación del índice se encuentra presente en el elemento. Si la clave de ordenación
no aparece en todos los elementos de la tabla, se considera que el índice es disperso.

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:

• Clave de partición: CustomerId


• El criterio de ordenación: OrderId

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

Versión de API 2012-08-10


1005
Amazon DynamoDB Guía para desarrolladores
Índices dispersos

OrderOpenDate establecido en la fecha en la que se realizó el pedido y borrarlo cuando el pedido se


haya completado. De ese modo, cuando consulte el índice disperso, los elementos devueltos estarán
ordenados en función de la fecha en que se realizó cada pedido.

Ejemplos de índices dispersos en DynamoDB


De forma predeterminada, los índices secundarios globales son dispersos. Cuando crea un índice
secundario global, especifica una clave de partición y, de forma opcional, una clave de ordenación. Solo
los elementos de la tabla principal que contienen esos atributos aparecen en el índice.

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.

Versión de API 2012-08-10


1006
Amazon DynamoDB Guía para desarrolladores
Agregación

Uso de índices secundarios globales para consultas


de agregación materializadas
Mantener métricas clave y agregaciones casi en tiempo real sobre datos que cambian rápidamente es algo
que las compañías cada vez valoran más, ya que les permite tomar decisiones rápidas. Por ejemplo, una
biblioteca de música quiere mostrar las canciones más descargadas prácticamente en tiempo real.

Pensemos en el diseño de la tabla de una biblioteca de música:

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.

Sobrecarga de índices secundarios globales


Aunque Amazon DynamoDB tiene una cuota predeterminada de 20 índices secundarios globales por tabla,
en la práctica, se pueden indexar muchos más de 20 campos de datos. A diferencia de las tablas de los
sistemas de administración de bases de datos relacionales (RDBMS), donde el esquema es uniforme,
en las tablas de DynamoDB pueden contener diferentes tipo de elementos de datos a la vez. Además,
un mismo atributo que se utilice en diferentes elementos puede contener tipos de información totalmente
distinta.

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.

Versión de API 2012-08-10


1007
Amazon DynamoDB Guía para desarrolladores
Sagmentación de GSI

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:

• Buscar un empleado por nombre en el índice secundario global utilizandoEmployee_Namecomo el valor


de la clave de partición y el nombre del empleado (por ejemploMurphy, John) como valor de clave de
ordenación.
• Utilizar el índice secundario global para buscar todos los empleados que trabajan en un determinado
almacén a través del ID de almacén (por ejemplo, Warehouse_01).
• Obtener una lista de las contrataciones recientes consultando el índice secundario global
enHR_confidentialComo valor de clave de partición y utilizando un intervalo de fechas en el valor de
clave de ordenación.

Uso de Sharing de Escritura de Índice Secundario


Global para Consultas de Tabla Selectiva
Con frecuencia, las aplicaciones necesitan identificar un pequeño subconjunto de elementos en una
tabla de Amazon DynamoDB que cumplan una determinada condición. Cuando estos elementos se
distribuyen aleatoriamente entre las claves de partición de la tabla, puede recurrir a un análisis de tabla
para recuperarlos. Esta opción puede ser costosa, pero funciona bien cuando una gran cantidad de
elementos en la tabla cumplen con la condición de búsqueda. Sin embargo, cuando el espacio clave es
grande y la condición de búsqueda es muy selectiva, esta estrategia puede causar una gran cantidad de
procesamiento innecesario.

Versión de API 2012-08-10


1008
Amazon DynamoDB Guía para desarrolladores
Creación de una réplica

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.

Uso de índices secundarios globales para crear una


réplica consistente
Puede utilizar un índice secundario global para crear una réplica coherente de una tabla. Crear una réplica
puede permitir realizar las siguientes tareas:

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

Versión de API 2012-08-10


1009
Amazon DynamoDB Guía para desarrolladores
Elementos grandes

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.

Prácticas recomendadas para almacenar elementos


y atributos grandes
En la actualidad, Amazon DynamoDB limita el tamaño de cada uno de los elementos que se almacenan en
una tabla (consulteCuotas de servicio, cuenta y tabla en Amazon DynamoDB (p. 1066)). Si la aplicación
necesita almacenar más datos en un elemento de lo que permite el límite de tamaño de DynamoDB, puede
intentar comprimir uno o varios atributos grandes o dividir el elemento en varios elementos (indizados
eficazmente mediante claves de ordenación). También puede almacenar el elemento como un objeto en
Amazon Simple Storage Service (Amazon S3) y almacenar el identificador de objetos de Amazon S3 en el
elemento de DynamoDB.

Compresión de valores de atributos grandes


Si se comprimen, es posible que se ajusten a los límites de los elementos de DynamoDB y se reduzcan los
costos de almacenamiento Los algoritmos de compresión como GZIP o LZO generan una salida binaria
que se puede almacenar en un tipo de atributo Binary.

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)

Versión de API 2012-08-10


1010
Amazon DynamoDB Guía para desarrolladores
Uso de Amazon S3

• Ejemplo: Control de atributos de tipo Binary mediante elAWS SDK for .NETAPI de bajo nivel (p. 495)

Almacenamiento de valores de atributos grandes en


Amazon S3
Como se indicó anteriormente, también puede aprovechar Amazon S3 para almacenar valores de atributos
grandes que no caben en un elemento de DynamoDB. Puede almacenar estos atributos como un objeto de
Amazon S3 y almacenar después el identificador del objeto en el elemento de DynamoDB.

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.

Si utiliza esta estrategia, tenga en cuenta lo siguiente:

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

Prácticas recomendadas para administrar datos de


series temporales en DynamoDB
Los principios generales de diseño de Amazon DynamoDB recomiendan utilizar el mínimo número de
tablas posible. En la mayoría de las aplicaciones, solo se necesita una tabla. Sin embargo, para los datos
de series temporales, a menudo lo mejor para administrarlos es usar una tabla por aplicación y periodo.

Patrón de diseño de los datos de series temporales


Imagine un caso típico de una serie temporal en el que quiere hacer un seguimiento de una gran cantidad
de eventos. Tiene un patrón de acceso de escritura que establece que se registren todos los eventos con
la fecha de hoy. El patrón de acceso de lectura podría establecer que los eventos de hoy se lean con más
frecuencia, que los eventos de ayer se lean con mucha menos frecuencia y que los eventos más antiguos
apenas se lean. Una manera de administrarlo consiste en incorporar la fecha y hora actuales en la clave
principal.

Normalmente, el siguiente patrón de diseño sirve para administrar este tipo de escenarios eficazmente:

Versión de API 2012-08-10


1011
Amazon DynamoDB Guía para desarrolladores
Ejemplos de tablas de series temporales

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

Ejemplos de tablas de series temporales


A continuación se muestra un ejemplo de datos de serie temporal. En él, la tabla actual está aprovisionada
con una capacidad de lectura/escritura mayor y las tablas anteriores se han reducido, porque el acceso a
ellas es infrecuente:

Prácticas recomendadas para administrar


relaciones de varios a varios
Las listas de adyacencia conforman un patrón de diseño que resulta muy útil para modelar relaciones de
varios a varios en Amazon DynamoDB. En otras cosas, constituyen un mecanismo para representar datos
gráficos (modos y límites) en DynamoDB.

Patrón de diseño de listas de adyacencia


Cuando varias entidades de una aplicación tienen una relación de varios a varios entre ellas, la relación
puede modelarse como una lista de adyacencia. En este patrón, todas las entidades del nivel superior (que
se corresponderían con los nodos en el modelo gráfico) se representan utilizando la clave de partición.
Cualquier relación con otras entidades (los límites en el modelo gráfico) se representa como un elemento
dentro de la partición, donde el valor de la clave de ordenación se establece en el ID de la entidad de
destino (nodo de destino).

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

Versión de API 2012-08-10


1012
Amazon DynamoDB Guía para desarrolladores
Listas de adyacencia

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.

El esquema sería similar al siguiente:

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.

Versión de API 2012-08-10


1013
Amazon DynamoDB Guía para desarrolladores
Gráficos materializados

Patrón de gráficos materializados


Muchas aplicaciones se crean en torno a la información que se tiene sobre las clasificaciones entre
homólogos, las relaciones comunes entre entidades, el estado de las entidades adyacentes y otros tipos
de flujos de trabajo gráficos. En estos tipos de aplicaciones, considere la posibilidad de utilizar el siguiente
patrón de diseño de esquemas.

Versión de API 2012-08-10


1014
Amazon DynamoDB Guía para desarrolladores
Gráficos materializados

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.

Versión de API 2012-08-10


1015
Amazon DynamoDB Guía para desarrolladores
Gráficos materializados

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.

Versión de API 2012-08-10


1016
Amazon DynamoDB Guía para desarrolladores
DynamoDB híbrida: RDBMS

Prácticas recomendadas para implementar un


sistema de bases de datos híbrido
En determinadas circunstancias, es posible que no resulte provechoso migrar de uno o varios sistemas
de administración de bases de datos relacionales (RDBMS) a Amazon DynamoDB. En estos casos, es
preferible crear un sistema híbrido.

Si no quiere migrar todo a DynamoDB


Por ejemplo, algunas organizaciones han hecho grandes inversiones en un código que genera multitud de
informes necesarios para la contabilidad y las operaciones. Para estas organizaciones, no es importante
el tiempo que se tarda en generar los informes. La flexibilidad de un sistema relacional se adapta bien a
este tipo de tarea, mientras que volver a crear todos estos informes en un contexto NoSQL podría resultar
extraordinariamente difícil.

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.

Cómo puede implementarse un sistema híbrido


DynamoDB puede aprovechar DynamoDB Streams yAWS Lambdapara integrarse a la perfección con uno
o varios sistemas de bases de datos relacionales existentes:

Un sistema que integra DynamoDB Streams yAWS Lambdapuede proporcionar varias ventajas:

• Puede funcionar como una caché persistente de vistas materializadas.


• Puede configurarse para que se vaya llenando gradualmente con los datos a medida que estos se
consultan y modifican en el sistema SQL. Esto significa que no es necesario rellenar previamente toda
la vista. Esto, a su vez, significa que es más probable que se utilice de manera eficiente la capacidad de
rendimiento aprovisionada.
• Tiene pocos costos administrativos y ofrece una gran disponibilidad y fiabilidad.

Para que este tipo de integración se implemente, deben darse principalmente tres tipos de
interoperaciones:

Versión de API 2012-08-10


1017
Amazon DynamoDB Guía para desarrolladores
Modelos relacionales

1. Rellenar la caché de DynamoDB incrementalmente. Cuando se necesita un elemento, se busca primero


en DynamoDB. Si no está ahí, se busca en el sistema SQL y se carga en DynamoDB.
2. Escriba a través de una caché de DynamoDB. Cuando un cliente cambia un valor en DynamoDB, se
desencadena una función Lambda que escribe los datos de nuevo en el sistema SQL.
3. Actualizar DynamoDB desde el sistema SQL. Cuando los procesos internos, como la administración
del inventario o los precios, cambian un valor en el sistema SQL, se desencadena un procedimiento
almacenado para propagar el cambio a la vista materializada de DynamoDB.

Estas operaciones son sencillas y no siempre se necesitan todas.

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.

Prácticas recomendadas para modelar datos


relacionales en DynamoDB
Las plataformas tradicionales del sistema de administración de bases de datos relacionales (RDBMS)
almacenan datos en una estructura relacional normalizada. Esta estructura reduce las estructuras de
datos jerárquicas a un conjunto de elementos comunes que se almacenan en varias tablas. El esquema
siguiente es un ejemplo de una aplicación genérica de registro de pedidos con un sistema de recursos
humanos auxiliar que respalda los sistemas de soporte comercial y de operaciones de un hipotético
fabricante.

Versión de API 2012-08-10


1018
Amazon DynamoDB Guía para desarrolladores
Modelos relacionales

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.

Versión de API 2012-08-10


1019
Amazon DynamoDB Guía para desarrolladores
Modelos relacionales

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:

SELECT * FROM Orders


INNER JOIN Order_Items ON Orders.Order_ID = Order_Items.Order_ID
INNER JOIN Products ON Products.Product_ID = Order_Items.Product_ID
INNER JOIN Inventories ON Products.Product_ID = Inventories.Product_ID
ORDER BY Quantity_on_Hand DESC

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.

DynamoDB escala bien por los siguientes motivos:

• 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:

SELECT * FROM Table_X WHERE Attribute_Y = "somevalue"

DynamoDB trabaja mucho menos para devolver los datos solicitados que el sistema RDBMS del ejemplo
anterior.

Versión de API 2012-08-10


1020
Amazon DynamoDB Guía para desarrolladores
Primeros pasos

Primeros pasos para modelar datos relacionales en


DynamoDB
Important

El diseño NoSQL requiere un modo de pensar distinto al diseño de RDBMS. En un sistema


RDBMS, puede crear un modelo de datos normalizados sin pensar en los patrones de acceso.
Posteriormente, podrá ampliar este modelo cuando surjan nuevos requisitos sobre preguntas y
consultas. Por el contrario, en Amazon DynamoDB, no debería empezar a diseñar el esquema
hasta que sepa las preguntas a las que tiene que responder. Es absolutamente esencial conocer
los problemas del negocio y los costos iniciales de los casos de uso de la aplicación.

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

Versión de API 2012-08-10


1021
Amazon DynamoDB Guía para desarrolladores
Ejemplo

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.

Ejemplo de modelado de datos relacionales en


DynamoDB
En este ejemplo, se describe cómo se modelan los datos relacionales en Amazon DynamoDB.
El diseño de las tablas de DynamoDB se corresponde con el esquema relacional de registro de
pedidos que se describe enModelos relacionales (p. 1018). Se ajusta alPatrón de diseño de listas de
adyacencia (p. 1012), que es un mecanismo habitual para representar estructuras de datos relacionales
en DynamoDB.

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:

1. HR-Employee - PK: EmployeeID, SK: Empleado Name


2. HR-Region - PK: RegionID, SK: Nombre de la región
3. HR-Country - PK: CountryId, SK: Country Name
4. HR-Location - PK: LocationID, SK: Country Name
5. HR-Job - PK: JobID, SK: Job Title
6. HR-Department - PK: DepartmentID, SK: DepartmentID
7. OE-Customer - PK: CustomerID, SK: AccountRepID
8. OE Order - PK OrderID, SK: CustomerID
9. OE Product - PK: ProductID, SK: Product Name (Nombre del producto)
10.OE-Warehouse - PK: WarehouseID, SK: Nombre de la región

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

Versión de API 2012-08-10


1022
Amazon DynamoDB Guía para desarrolladores
Ejemplo

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.

ItemsPerRCU = 4KB / AvgItemSize

PartitionMaxReadRate = 3K * ItemsPerRCU

N = MaxRequiredIO / PartitionMaxReadRate

Por ejemplo, supongamos que sus previsiones son las siguientes:

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

En esa tabla, el cálculo del factor N sería similar al siguiente.

ItemsPerRCU = 4KB / 250B = 16

PartitionMaxReadRate = 3K * 16 = 48K

N = (0.2 * 3M) / 48K = 13

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.

Versión de API 2012-08-10


1023
Amazon DynamoDB Guía para desarrolladores
Consulta y examen

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.

Prácticas recomendadas para consultar y examinar


datos
En esta sección se describen algunas prácticas recomendadas relativas al uso
deQueryyScanOperaciones en Amazon DynamoDB.

Consideraciones sobre el desempeño de los


exámenes
En general,ScanLas operaciones son menos eficientes que otras operaciones de DynamoDB. AScanLa
operación siempre examina la tabla o el índice secundario. Luego, filtra los valores para proporcionar el
resultado que desea, en esencia, agrega el paso adicional de eliminar los datos del conjunto de resultados.

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.

Evitar los picos repentinos en la actividad de lectura


Al crear una tabla, se establecen los requisitos de unidades de capacidad de lectura y escritura. Para las
lecturas, las unidades de capacidad se expresan como el número de solicitudes de consistencia alta de
lectura de datos de 4 KB de 4 KB por segundo. Para obtener lecturas consistentes finales, una unidad
de capacidad de lectura es de dos solicitudes de lectura de 4 KB por segundo. AScanUna operación
realiza lecturas consistentes finales de forma predeterminada y puede devolver hasta 1 MB (una página)
de datos. Por lo tanto, una únicaScanLa solicitud puede consumir (tamaño de página de 1 MB de /tamaño

Versión de API 2012-08-10


1024
Amazon DynamoDB Guía para desarrolladores
Evite los picos

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.

El problema no es sólo el aumento repentino de unidades de capacidad que elScanUsarUse. Es probable


que el examen consuma también todas sus unidades de capacidad de la misma partición, porque el
examen solicita elementos de lectura que se encuentran contiguos en la partición. Esto significa que
la solicitud se dirige a la misma partición, con lo que provoca que se consuman todas sus unidades de
capacidad e impone una limitación controlada que impide que la partición reciba otras solicitudes. Si la
solicitud de lectura de datos se distribuye entre varias particiones, la operación no aceleraría una partición
determinada.

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.

Versión de API 2012-08-10


1025
Amazon DynamoDB Guía para desarrolladores
Evite los picos

Como se ilustra aquí, el pico de uso puede afectar el rendimiento aprovisionado de la tabla de varias
maneras:

1. Buena: Distribución uniforme de las solicitudes y el tamaño


2. No tan bueno: Solicitudes frecuentes en ráfagas
3. Mala: Algunas solicitudes grandes aleatorias

Versión de API 2012-08-10


1026
Amazon DynamoDB Guía para desarrolladores
Examen en paralelo

4. Mala: Operaciones de examen de gran tamaño

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.

• Reducir el tamaño de página

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

Cómo sacar partido de los exámenes en paralelo


Muchas aplicaciones pueden beneficiarse si se usa en paraleloScanOperaciones en lugar de
secuencialmente. Por ejemplo, una aplicación que procesa una gran tabla de datos históricos puede
llevar a cabo un examen en paralelo mucho más rápidamente que uno secuencial. Varios subprocesos de
trabajo contenidos en un proceso de "barrido" en segundo plano podrían examinar una tabla con menor
prioridad sin afectar al tráfico de producción. En todos estos ejemplos, se utiliza una operación Scan de tal
forma que no priva a las demás aplicaciones de los recursos de desempeño provisionado.

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:

• El tamaño de la tabla es de 20 GB o mayor.


• El desempeño de lectura provisionado de la tabla no se está utilizando en su totalidad.
• Las operaciones Scan secuenciales son demasiado lentas.

Versión de API 2012-08-10


1027
Amazon DynamoDB Guía para desarrolladores
Examen en paralelo

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.

Versión de API 2012-08-10


1028
Amazon DynamoDB Guía para desarrolladores
Integración con Amazon Cognito

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)

ConfiguraciónAWSCredenciales en sus archivos


mediante Amazon Cognito
La forma recomendada de obtenerAWSPara las aplicaciones web y para móviles es utilizar Amazon
Cognito. Amazon Cognito le evita tener que codificar de forma rígida lasAWSen sus archivos.
UsarUseAWS Identity and Access ManagementPara generar credenciales temporales para los usuarios
autenticados y no autenticados de las aplicaciones.

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:

Para configurar credenciales para integrarlas con Amazon Cognito

1. Cree un grupo de identidades de Amazon Cognito que permita identidades no autenticadas.

aws cognito-identity create-identity-pool \


--identity-pool-name DynamoPool \
--allow-unauthenticated-identities \
--output json
{
"IdentityPoolId": "us-west-2:12345678-1ab2-123a-1234-a12345ab12",
"AllowUnauthenticatedIdentities": true,
"IdentityPoolName": "DynamoPool"
}

2. Copie la política siguiente en un archivo denominado myCognitoPolicy.json. Cambie el


identificador del grupo de identidades (us-west-2:12345678-1ab2-123a-1234-a12345ab12)
por su propio IdentityPoolId obtenido en el paso anterior:

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",

Versión de API 2012-08-10


1029
Amazon DynamoDB Guía para desarrolladores
Integración con Amazon Cognito

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

aws iam create-role --role-name Cognito_DynamoPoolUnauth \


--assume-role-policy-document file://PathToFile/myCognitoPolicy.json --output json

4. Conceda alCognito_DynamoPoolUnauthAcceso pleno al servicio de DynamoDB adjuntándole una


política administrada (AmazonDynamoDBFullAccess).

aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/


AmazonDynamoDBFullAccess \
--role-name Cognito_DynamoPoolUnauth

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.

aws iam get-role --role-name Cognito_DynamoPoolUnauth --output json

6. Agregue el rol Cognito_DynamoPoolUnauth al grupo de identidades DynamoPool. El formato que


debe especificar es KeyName=string, donde KeyName es unauthenticated y string es el ARN del
rol obtenido en el paso anterior.

aws cognito-identity set-identity-pool-roles \


--identity-pool-id "us-west-2:12345678-1ab2-123a-1234-a12345ab12" \
--roles unauthenticated=arn:aws:iam::123456789012:role/Cognito_DynamoPoolUnauth --
output json

7. Especifique las credenciales de Amazon Cognito en sus archivos. Modifique los valores de
IdentityPoolId y RoleArn en consecuencia.

AWS.config.credentials = new AWS.CognitoIdentityCredentials({


IdentityPoolId: "us-west-2:12345678-1ab2-123a-1234-a12345ab12",
RoleArn: "arn:aws:iam::123456789012:role/Cognito_DynamoPoolUnauth"
});

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

Carga de datos desde DynamoDB en Amazon


Redshift
Amazon Redshift complementa Amazon DynamoDB con prestaciones avanzadas de inteligencia
empresarial y una potente interfaz basada en SQL. Cuando se copian datos de una tabla de DynamoDB
en Amazon Redshift, se pueden llevar a cabo consultas complejas de análisis de esos datos, lo que incluye
uniones con otras tablas del clúster de 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.

A continuación se muestra un ejemplo de comando COPY de Amazon Redshift SQL en:

copy favoritemovies from 'dynamodb://my-favorite-movies-table'


credentials 'aws_access_key_id=<Your-Access-Key-ID>;aws_secret_access_key=<Your-Secret-
Access-Key>'
readratio 50;

En este ejemplo, la tabla de origen de DynamoDB esmy-favorite-movies-table. La tabla de


destino de Amazon Redshift esfavoritemovies. La cláusula readratio 50 regula el porcentaje
de desempeño provisionado que se consume; en este caso, el comando COPY utilizará como máximo
un 50 % de las unidades de capacidad de lectura provisionadas para my-favorite-movies-table.
Recomendamos encarecidamente establecer este porcentaje en un valor menor que el promedio de
desempeño provisionado sin utilizar.

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:

• Carga de datos desde una tabla de DynamoDB


• The COPY command
• Ejemplos de COPY

Versión de API 2012-08-10


1031
Amazon DynamoDB Guía para desarrolladores
Integración con Amazon EMR

Procesamiento de datos de DynamoDB con Apache


Hive en Amazon EMR
Amazon DynamoDB se integra con Apache Hive, una aplicación de almacenamiento de datos que se
ejecuta en Amazon EMR. Hive puede leer y escribir datos en las tablas de DynamoDB, lo que le permite:

• Consultar datos de DynamoDB en directo utilizando un lenguaje semejante a SQL (HiveQL).


• Copiar datos de una tabla de DynamoDB en un bucket de Amazon S3 y viceversa.
• Copiar datos de una tabla de DynamoDB en Hadoop Distributed File System (HDFS) y viceversa.
• Realizar operaciones de unión con las tablas de DynamoDB.

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

Versión de API 2012-08-10


1032
Amazon DynamoDB Guía para desarrolladores
Tutorial: Uso de Amazon DynamoDB y Apache Hive

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.

Tutorial: Uso de Amazon DynamoDB y Apache Hive


En este tutorial, lanzaremos un clúster de Amazon EMR y, a continuación, usaremos Apache Hive para
procesar los datos almacenados en una tabla de DynamoDB.

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

Para obtener más información, consulte el Hive Tutorial.

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

Paso 1: Creación de un par de claves de Amazon EC2 (p. 1033)

Paso 1: Creación de un par de claves de Amazon EC2


En este paso, crearemos el key pair Amazon EC2 que se requiere para conectarse a un nodo de líder
Amazon EMR y ejecutar comandos de Hive.

1. Inicie sesión en laAWS Management ConsoleAbra la consola de Amazon EC2 enhttps://


console.aws.amazon.com/ec2/.
2. Elija una región (por ejemplo,US West (Oregon)). Debe ser la misma región en la que se encuentra
la tabla de DynamoDB.
3. En el panel de navegación, seleccione Key Pairs (Pares de claves).

Versión de API 2012-08-10


1033
Amazon DynamoDB Guía para desarrolladores
Tutorial: Uso de Amazon DynamoDB y Apache Hive

4. Seleccione Create Key Pair.


5. En Key pair name, escriba un nombre para el par de claves (por ejemplo, mykeypair) y después elija
Create.
6. Descargue el archivo de clave privada. El nombre de archivo terminará
por.pem(comomykeypair.pem). Mantenga este archivo de clave privada en un lugar seguro. Lo
necesitará para obtener acceso a cualquier clúster de Amazon EMR que lance con este key pair.
Important

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

Paso 2: Iniciar un clúster de Amazon EMR (p. 1034)

Paso 2: Iniciar un clúster de Amazon EMR


En este paso, configuraremos y lanzaremos un clúster de Amazon EMR. Ya estarán instalados en el
clúster tanto Hive como un controlador de almacenamiento para DynamoDB.

1. Abra la consola de Amazon EMR enhttps://console.aws.amazon.com/elasticmapreduce/.


2. Elija Create Cluster (Crear clúster).
3. En la página Create Cluster - Quick Options, haga lo 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.

No cambie los valores predeterminados de los demás ajustes.


4. Elija Create cluster.

Se tardan unos minutos en lanzar el clúster. Puede utilizar laDetalles de clústerEn la consola de Amazon
EMR para monitorizar el progreso.

Cuando el estado cambia a Waiting, el clúster está preparado para usarlo.

Archivos log del clúster y Amazon S3


Un clúster de Amazon EMR genera archivos log que contienen información acerca del estado del clúster
y sobre depuración. La configuración predeterminada deCrear clúster - Opciones rápidasincluyen la
configuración del registro de Amazon EMR.

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.

Versión de API 2012-08-10


1034
Amazon DynamoDB Guía para desarrolladores
Tutorial: Uso de Amazon DynamoDB y Apache Hive

Paso siguiente

Paso 3: Connect con el nodo directriz (p. 1035)

Paso 3: Connect con el nodo directriz


Cuando el estado de su clúster de Amazon EMR cambia aWaiting, ya puede conectarse al nodo de
directriz mediante SSH y llevar a cabo operaciones de línea de comandos.

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

Paso 4: Carga de datos en HDFS (p. 1035)

Paso 4: Carga de datos en HDFS


En este paso, copiaremos un archivo de datos en Hadoop Distributed File System (HDFS) y, a
continuación, crearemos una tabla Hive externa mapeada con ese archivo de datos.

Descarga del ejemplo de datos

1. Descargue el ejemplo de archivo de datos (features.zip):

wget https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/
features.zip

2. Extraiga el archivo features.txt del archivo comprimido:

unzip features.zip

3. Vea las primeras líneas del archivo features.txt:

head features.txt

El resultado debe ser parecido al siguiente:

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

Versión de API 2012-08-10


1035
Amazon DynamoDB Guía para desarrolladores
Tutorial: Uso de Amazon DynamoDB y Apache Hive

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

Lafeatures.txtEl archivo contiene un subconjunto de los datos del Consejo Estadense de


Nombres Geográficos (http://geonames.usgs.gov/domestic/download_data.htm). Los campos de cada
línea representan lo siguiente:

• Identificador del accidente geográfico (identificador único)


• Nombre
• Clase (lago, bosque, arroyo, etc.)
• Estado
• Latitud (grados)
• Longitud (grados)
• Altitud (en pies)
4. En el símbolo del sistema, escriba el siguiente comando:

hive

El símbolo del sistema cambia a lo siguiente: hive>


5. Escriba la siguiente instrucción de HiveQL para crear una tabla de Hive nativa:

CREATE TABLE hive_features


(feature_id BIGINT,
feature_name STRING ,
feature_class STRING ,
state_alpha STRING,
prim_lat_dec DOUBLE ,
prim_long_dec DOUBLE ,
elev_in_ft BIGINT)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '|'
LINES TERMINATED BY '\n';

6. Escriba la siguiente instrucción de HiveQL para cargar datos en la tabla:

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:

SELECT state_alpha, COUNT(*)


FROM hive_features
GROUP BY state_alpha;

El resultado debería ser una lista de estados y el número de accidentes geográficos de cada uno de
ellos.

Paso siguiente

Paso 5: Copiar datos en DynamoDB (p. 1037)

Versión de API 2012-08-10


1036
Amazon DynamoDB Guía para desarrolladores
Tutorial: Uso de Amazon DynamoDB y Apache Hive

Paso 5: Copiar datos en DynamoDB


En este paso, copiaremos los datos de la tabla de Hive (hive_features) a una nueva tabla en
DynamoDB.

1. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.


2. Seleccione Create Table (Crear tabla).
3. En la página Create DynamoDB table, haga lo siguiente:

a. EnTabla, escribaFeatures.
b. ParaClave principal, en elClave de particiónfield, escribaId. Establezca el tipo de datos en
Number (Número).

ClearUtilizar la configuración predeterminada. En Provisioned Capacity, especifique lo siguiente:

• Unidades de capacidad de lectura—10


• Unidades de capacidad de escritura—10

Seleccione Create (Crear).


4. En el símbolo del sistema de Hive, escriba la instrucción de HiveQL siguiente:

CREATE EXTERNAL TABLE ddb_features


(feature_id BIGINT,
feature_name STRING,
feature_class STRING,
state_alpha STRING,
prim_lat_dec DOUBLE,
prim_long_dec DOUBLE,
elev_in_ft BIGINT)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES(
"dynamodb.table.name" = "Features",

"dynamodb.column.mapping"="feature_id:Id,feature_name:Name,feature_class:Class,state_alpha:State,p
);

Ahora, hemos establecido un mapeo entre Hive y la tabla Features de DynamoDB.


5. Escriba la instrucción de HiveQL siguiente para importar datos en DynamoDB:

INSERT OVERWRITE TABLE ddb_features


SELECT
feature_id,
feature_name,
feature_class,
state_alpha,
prim_lat_dec,
prim_long_dec,
elev_in_ft
FROM hive_features;

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:

a. En el panel de navegación de la consola de DynamoDB, elijaTablas.


b. Elija la tabla Features y, a continuación, elija la pestaña Items para ver los datos.
Versión de API 2012-08-10
1037
Amazon DynamoDB Guía para desarrolladores
Tutorial: Uso de Amazon DynamoDB y Apache Hive

Paso siguiente

Paso 6: Consultar los datos de la tabla de DynamoDB (p. 1038)

Paso 6: Consultar los datos de la tabla de DynamoDB


En este paso, vamos a usar HiveQL para consultar la tabla Features en DynamoDB. Pruebe las siguientes
consultas en Hive:

1. Todos los tipos de accidentes geográficos (feature_class) por orden alfabético:

SELECT DISTINCT feature_class


FROM ddb_features
ORDER BY feature_class;

2. Todos los lagos que empiezan por la letra "M":

SELECT feature_name, state_alpha


FROM ddb_features
WHERE feature_class = 'Lake'
AND feature_name LIKE 'M%'
ORDER BY feature_name;

3. Los estados que tienen al menos tres accidentes geográficos con más de una milla de altitud
(5280 pies/1609,34 metros):

SELECT state_alpha, feature_class, COUNT(*)


FROM ddb_features
WHERE elev_in_ft > 5280
GROUP by state_alpha, feature_class
HAVING COUNT(*) >= 3
ORDER BY state_alpha, feature_class;

Paso siguiente

Paso 7: (Opcional) Limpieza (p. 1038)

Paso 7: (Opcional) Limpieza


Una vez completado el tutorial, puede continuar leyendo esta sección para obtener más información sobre
cómo usar los datos de DynamoDB en Amazon EMR. Mientras lo hace, puede que prefiera mantener el
clúster de Amazon EMR en funcionamiento.

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.

1. Finalizar el clúster de Amazon EMR:

a. Abra la consola de Amazon EMR enhttps://console.aws.amazon.com/elasticmapreduce/.


b. Elija el clúster de Amazon EMR, elijaFinalizarConfirme la selección.
2. Elimine la tabla Features de DynamoDB:

a. Abra la consola de DynamoDB enhttps://console.aws.amazon.com/dynamodb/.


b. En el panel de navegación, elija Tables (Tablas).
c. Elija la tabla Features. En el menú Actions, elija Delete Table.
3. Elimine el bucket de Amazon S3 que contiene los archivos de registro de Amazon EMR:

Versión de API 2012-08-10


1038
Amazon DynamoDB Guía para desarrolladores
Crear una tabla externa en Hive

a. Abra la consola de Amazon S3 en https://console.aws.amazon.com/s3.


b. En la lista de buckets, elijaaws-logs- accountID-region, dondeaccountIDEs
suAWSNúmero de cuenta yregiónEs la región en la que lanzó el clúster.
c. En el menú Action, elija Delete.

Crear una tabla externa en Hive


EnTutorial: Uso de Amazon DynamoDB y Apache Hive (p. 1033), hemos creado una tabla de Hive
externa mapeada a una tabla de DynamoDB. Al emitir instrucciones de HiveQL para la tabla externa, las
operaciones de lectura y escritura se transmitían a la tabla de DynamoDB.

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.

Si ya no necesita la tabla externa, puede eliminarla mediante la herramientaDROP TABLEstatement.


En este caso,DROP TABLESolo elimina la tabla externa de Hive. No afecta a la tabla de DynamoDB
subyacente ni a ninguno de los datos que contiene.

Temas
• Sintaxis de CREATE EXTERNAL TABLE (p. 1039)
• Mapeos de tipos de datos (p. 1040)

Sintaxis de CREATE EXTERNAL TABLE


A continuación se muestra la sintaxis de HiveQL para crear una tabla de Hive externa mapeada a una tabla
de DynamoDB:

CREATE EXTERNAL TABLE hive_table


(hive_column1_name hive_column1_datatype, hive_column2_name hive_column2_datatype...)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES (
"dynamodb.table.name" = "dynamodb_table",
"dynamodb.column.mapping" =
"hive_column1_name:dynamodb_attribute1_name,hive_column2_name:dynamodb_attribute2_name..."
);

La línea 1 es el principio de la instrucción CREATE EXTERNAL TABLE, en la que se indica el nombre de la


tabla de Hive (hive_table) que se desea a crear.

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

Versión de API 2012-08-10


1039
Amazon DynamoDB Guía para desarrolladores
Crear una tabla externa en Hive

La línea 4 es el principio de la cláusula TBLPROPERTIES, en la que se definen los parámetros siguientes


de DynamoDBStorageHandler:

• dynamodb.table.nameEl nombre de la tabla de DynamoDB.


• dynamodb.column.mapping: pares de los nombres de las columnas de la tabla de Hive
y sus atributos correspondientes en la tabla de DynamoDB. Cada par tiene el formato
nombre_de_columna_de_hive:nombre_de_atributo_de_dynamodb y los pares están separados entre sí
por comas.

Tenga en cuenta lo siguiente:

• 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

LaCREATE EXTERNAL TABLENo lleva a cabo ninguna validación en elTBLPROPERTIESCláusula


Los valores que proporcione para dynamodb.table.name y dynamodb.column.mapping
solamente serán evaluados por la clase DynamoDBStorageHandler cuando se intente obtener
acceso a la tabla.

Mapeos de tipos de datos


En la tabla siguiente se muestran los tipos de datos de DynamoDB y aquellos de Hive que son
compatibles:

Tipo de dato de DynamoDB Tipo de datos de Hive

Cadena STRING

Número BIGINT o bien DOUBLE

Binario BINARY

String Set ARRAY<STRING>

Number Set ARRAY<BIGINT> o bien ARRAY<DOUBLE>

Binary Set ARRAY<BINARY>

Note

Los siguientes tipos de datos de DynamoDB no son compatibles con


laDynamoDBStorageHandlerPor lo que estos no se pueden utilizar
condynamodb.column.mapping:

Versión de API 2012-08-10


1040
Amazon DynamoDB Guía para desarrolladores
Procesamiento de instrucciones de HiveQL

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

Procesamiento de instrucciones de HiveQL


Hive es una aplicación que se ejecuta en Hadoop, que es un marco de trabajo orientado al procesamiento
por lotes para ejecutar trabajos de MapReduce. Cuando emite una instrucción de HiveQL, Hive determina
si puede devolver los resultados de forma inmediata o si se debe enviar un trabajo de MapReduce.

Por ejemplo, fíjese en laddb_featuresTabla (deTutorial: Uso de Amazon DynamoDB y Apache


Hive (p. 1033)). La siguiente consulta de Hive imprime las abreviaturas de los estados y el número de
cumbres de cada uno de ellos:

SELECT state_alpha, count(*)


FROM ddb_features
WHERE feature_class = 'Summit'
GROUP BY state_alpha;

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

Versión de API 2012-08-10


1041
Amazon DynamoDB Guía para desarrolladores
Consulta de datos en DynamoDB

TN 1
TX 1
UT 4
VA 1
VT 2
WA 2
WY 3
Time taken: 8.753 seconds, Fetched: 25 row(s)

Monitorización y cancelación de trabajos


Cuando Hive lanza un trabajo de Hadoop, imprime el resultado de ese trabajo. El estado de realización
del trabajo se actualiza a medida que este progresa. En algunos casos, el estado podría tardar mucho en
actualizarse. Esto puede suceder cuando se consulta una tabla de DynamoDB de gran tamaño con un
ajuste bajo de capacidad de lectura provisionada.

Si necesita cancelar el trabajo antes de que finalice, puede escribirCtrl+CEn cualquier momento.

Consulta de datos en DynamoDB


En los siguientes ejemplos se muestran algunas formas de usar HiveQL para consultar los datos
almacenados en DynamoDB.

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)

Uso de funciones de agregación


HiveQL proporciona funciones integradas para sintetizar los valores de los datos. Por ejemplo, puede
utilizar elMAXPara encontrar el mayor valor para una columna seleccionada. En el siguiente ejemplo se
devuelve la altitud del accidente geográfico más alto del estado de Colorado.

SELECT MAX(elev_in_ft)
FROM ddb_features
WHERE state_alpha = 'CO';

Uso de las cláusulas GROUP BY y HAVING


Puede utilizar la cláusula GROUP BY para recopilar datos a través de varios registros. Esto se utiliza a
menudo con una función agregada, comoSUM,COUNT,MIN, o bienMAX. También puede usar la cláusula
HAVING para descartar todos los resultados que no cumplan determinados criterios.

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.

SELECT state_alpha, max(elev_in_ft)


FROM ddb_features
GROUP BY state_alpha
HAVING count(*) >= 5;

Versión de API 2012-08-10


1042
Amazon DynamoDB Guía para desarrolladores
Consulta de datos en DynamoDB

Unión de dos tablas de DynamoDB


En el siguiente ejemplo se asigna otra tabla Hive (east_coast_states) en una tabla en DynamoDB.
LaSELECTLa instrucción es una unión de estas dos tablas. La unión se calcula en el clúster y se devuelve.
La unión no tiene lugar en DynamoDB.

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:

CREATE EXTERNAL TABLE ddb_east_coast_states (state_name STRING, state_alpha STRING)


STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "EastCoastStates",
"dynamodb.column.mapping" = "state_name:StateName,state_alpha:StateAbbrev");

La unión siguiente devuelve los estados de la costa oriental de Estados Unidos que tienen al menos tres
accidentes geográficos:

SELECT ecs.state_name, f.feature_class, COUNT(*)


FROM ddb_east_coast_states ecs
JOIN ddb_features f on ecs.state_alpha = f.state_alpha
GROUP BY ecs.state_name, f.feature_class
HAVING COUNT(*) >= 3;

Unión de tablas de orígenes diferentes


En el siguiente ejemplo, s3_east_coast_states es una tabla de Hive asociada a un archivo CSV
almacenado en Amazon S3. Laddb_featuresLa tabla está asociada con datos de DynamoDB. En el
ejemplo siguiente se unen estas dos tablas y se devuelven los accidentes geográficos de los estados
cuyos nombres comienzan por "New".

create external table s3_east_coast_states (state_name STRING, state_alpha STRING)


ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
LOCATION 's3://bucketname/path/subpath/';

SELECT ecs.state_name, f.feature_name, f.feature_class


FROM s3_east_coast_states ecs
JOIN ddb_features f
ON ecs.state_alpha = f.state_alpha
WHERE ecs.state_name LIKE 'New%';

Versión de API 2012-08-10


1043
Amazon DynamoDB Guía para desarrolladores
Copia de datos en y desde Amazon DynamoDB

Copia de datos en y desde Amazon DynamoDB


En el navegadorTutorial: Uso de Amazon DynamoDB y Apache Hive (p. 1033), hemos copiado datos de
una tabla de Hive nativa en una tabla de DynamoDB externa y, a continuación, hemos consultado la tabla
de DynamoDB externa. La tabla es externa porque existe fuera de Hive. Aunque se elimine la tabla de Hive
que está mapeada a ella, la tabla de DynamoDB no se verá afectada.

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)

Copia de datos entre DynamoDB y una tabla de Hive nativa


Si tiene datos en una tabla de DynamoDB, puede copiarlos en una tabla de Hive nativa. Al hacerlo,
obtendrá una instantánea de los datos en el momento de la copia.

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.

Example Desde DynamoDB a una tabla de Hive nativa


Puede crear una tabla de Hive nativa y rellenarla con datos de ddb_features, así:

CREATE TABLE features_snapshot AS


SELECT * FROM ddb_features;

A continuación, puede actualizar los datos en cualquier momento:

INSERT OVERWRITE TABLE features_snapshot


SELECT * FROM ddb_features;

En estos ejemplos, la subconsultaSELECT * FROM ddb_featuresRecuperará todos los datos


deddb_features. Si solamente desea copiar un subconjunto de los datos, puede usar una cláusula WHERE
en la subconsulta.

En el siguiente ejemplo se crea una tabla de Hive nativa que únicamente contiene algunos de atributos de
lagos y cumbres:

CREATE TABLE lakes_and_summits AS


SELECT feature_name, feature_class, state_alpha
FROM ddb_features

Versión de API 2012-08-10


1044
Amazon DynamoDB Guía para desarrolladores
Copia de datos en y desde Amazon DynamoDB

WHERE feature_class IN ('Lake','Summit');

Example Desde una tabla de Hive nativa a DynamoDB

La instrucción de HiveQL siguiente permite copiar los datos de la tabla de Hive nativa a ddb_features:

INSERT OVERWRITE TABLE ddb_features


SELECT * FROM features_snapshot;

Copia de datos entre DynamoDB y Amazon S3


Si tiene datos en una tabla de DynamoDB, puede usar Hive para copiarlos en un bucket de Amazon S3.

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:

1. Abra la consola de Amazon EMR enhttps://console.aws.amazon.com/elasticmapreduce/.


2. En Name, elija el clúster.
3. La URI aparece en Log URI bajo Configuration Details.
4. Anote la ruta raíz del bucket. La convención de nomenclatura es:

s3://aws-logs-accountID-region

whereaccountIDEs suAWSID de cuenta y región es elAWSRegión para el bucket de.

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)

Copia de datos mediante el formato predeterminado de Hive


Example De DynamoDB a Amazon S3

Utilizar unINSERT OVERWRITEPara escribir directamente en Amazon S3.

INSERT OVERWRITE DIRECTORY 's3://aws-logs-123456789012-us-west-2/hive-test'


SELECT * FROM ddb_features;

Versión de API 2012-08-10


1045
Amazon DynamoDB Guía para desarrolladores
Copia de datos en y desde Amazon DynamoDB

El archivo de datos de Amazon S3 tiene este aspecto:

920709^ASoldiers Farewell Hill^ASummit^ANM^A32.3564729^A-108.33004616135


1178153^AJones Run^AStream^APA^A41.2120086^A-79.25920781260
253838^ASentinel Dome^ASummit^ACA^A37.7229821^A-119.584338133
264054^ANeversweet Gulch^AValley^ACA^A41.6565269^A-122.83614322900
115905^AChacaloochee Bay^ABay^AAL^A30.6979676^A-87.97388530

Cada campo se separa por un carácter SOH (inicio del encabezado, 0x01). En el archivo, SOH aparece
como^A.

Example De Amazon S3 a DynamoDB

1. Cree una tabla externa que apunte a los datos sin formato de Amazon S3.

CREATE EXTERNAL TABLE s3_features_unformatted


(feature_id BIGINT,
feature_name STRING ,
feature_class STRING ,
state_alpha STRING,
prim_lat_dec DOUBLE ,
prim_long_dec DOUBLE ,
elev_in_ft BIGINT)
LOCATION 's3://aws-logs-123456789012-us-west-2/hive-test';

2. Copie los datos en DynamoDB.

INSERT OVERWRITE TABLE ddb_features


SELECT * FROM s3_features_unformatted;

Copia de datos con un formato especificado por el usuario


Si desea especificar su propio carácter separador de campos, puede crear una tabla externa que esté
mapeada al bucket de Amazon S3. Puede utilizar esta técnica para crear archivos de datos con valores
separados por comas (CSV).

Example De DynamoDB a 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.

CREATE EXTERNAL TABLE s3_features_csv


(feature_id BIGINT,
feature_name STRING,
feature_class STRING,
state_alpha STRING,
prim_lat_dec DOUBLE,
prim_long_dec DOUBLE,
elev_in_ft BIGINT)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
LOCATION 's3://aws-logs-123456789012-us-west-2/hive-test';

2. Copie los datos de DynamoDB.

INSERT OVERWRITE TABLE s3_features_csv


SELECT * FROM ddb_features;

Versión de API 2012-08-10


1046
Amazon DynamoDB Guía para desarrolladores
Copia de datos en y desde Amazon DynamoDB

El archivo de datos de Amazon S3 tiene este aspecto:

920709,Soldiers Farewell Hill,Summit,NM,32.3564729,-108.3300461,6135


1178153,Jones Run,Stream,PA,41.2120086,-79.2592078,1260
253838,Sentinel Dome,Summit,CA,37.7229821,-119.58433,8133
264054,Neversweet Gulch,Valley,CA,41.6565269,-122.8361432,2900
115905,Chacaloochee Bay,Bay,AL,30.6979676,-87.9738853,0

Example De Amazon S3 a DynamoDB

Con una sola instrucción de HiveQL, puede rellenar la tabla de DynamoDB usando los datos de Amazon
S3:

INSERT OVERWRITE TABLE ddb_features


SELECT * FROM s3_features_csv;

Copia de datos sin mapeo de columnas


Puede copiar datos de DynamoDB en formato sin procesar y escribirlos en Amazon S3 sin especificar
ningún tipo de datos ni mapeo de columnas. Puede utilizar este método para crear un archivo comprimido
de los datos de DynamoDB y almacenarlos en 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.

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

CREATE EXTERNAL TABLE ddb_features_no_mapping


(item MAP<STRING, STRING>)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "Features");

2. Cree otra tabla externa asociada con el bucket de Amazon S3.

CREATE EXTERNAL TABLE s3_features_no_mapping


(item MAP<STRING, STRING>)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\t'
LINES TERMINATED BY '\n'
LOCATION 's3://aws-logs-123456789012-us-west-2/hive-test';

3. Copie los datos de DynamoDB a Amazon S3.

INSERT OVERWRITE TABLE s3_features_no_mapping


SELECT * FROM ddb_features_no_mapping;

El archivo de datos de Amazon S3 tiene este aspecto:

Name^C{"s":"Soldiers Farewell
Hill"}^BState^C{"s":"NM"}^BClass^C{"s":"Summit"}^BElevation^C{"n":"6135"}^BLatitude^C{"n":"32.3564729"

Versión de API 2012-08-10


1047
Amazon DynamoDB Guía para desarrolladores
Copia de datos en y desde Amazon DynamoDB

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.

Example De Amazon S3 a DynamoDB


Con una sola instrucción de HiveQL, puede rellenar la tabla de DynamoDB usando los datos de Amazon
S3:

INSERT OVERWRITE TABLE ddb_features_no_mapping


SELECT * FROM s3_features_no_mapping;

Visualización de los datos en Amazon S3


Si usa SSH para conectarse al nodo de directriz, puede usar laAWS Command Line Interface(AWS CLI)
para obtener acceso a los datos que Hive escribió en Amazon S3.

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/

El aspecto de la respuesta debe ser parecido al siguiente:

2016-11-01 23:19:54 81983 000000_0

El nombre de archivo (000000_0) lo genera el sistema.


3. (Opcional) Puede copiar el archivo de datos de Amazon S3 al sistema de archivos local en el nodo de
directriz. Después de hacerlo, puede utilizar las utilidades estándar de la línea de comandos de Linux
para trabajar con los datos del archivo.

aws s3 cp s3://aws-logs-123456789012-us-west-2/hive-test/000000_0 .

El aspecto de la respuesta debe ser parecido al siguiente:

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.

Versión de API 2012-08-10


1048
Amazon DynamoDB Guía para desarrolladores
Copia de datos en y desde Amazon DynamoDB

Copia de datos entre DynamoDB y HDFS


Si tiene datos en una tabla de DynamoDB, puede usar Hive para copiarlos en Hadoop Distributed File
System (HDFS).

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)

Copia de datos mediante el formato predeterminado de Hive


Example De DynamoDB a HDFS

Use una instrucción INSERT OVERWRITE para escribir directamente en HDFS.

INSERT OVERWRITE DIRECTORY 'hdfs:///user/hadoop/hive-test'


SELECT * FROM ddb_features;

El archivo de datos de HDFS tiene este aspecto:

920709^ASoldiers Farewell Hill^ASummit^ANM^A32.3564729^A-108.33004616135


1178153^AJones Run^AStream^APA^A41.2120086^A-79.25920781260
253838^ASentinel Dome^ASummit^ACA^A37.7229821^A-119.584338133
264054^ANeversweet Gulch^AValley^ACA^A41.6565269^A-122.83614322900
115905^AChacaloochee Bay^ABay^AAL^A30.6979676^A-87.97388530

Cada campo se separa por un carácter SOH (inicio del encabezado, 0x01). En el archivo, SOH aparece
como^A.

Example De HDFS a DynamoDB

1. Cree una tabla externa mapeada a los datos sin formato de HDFS.

CREATE EXTERNAL TABLE hdfs_features_unformatted


(feature_id BIGINT,
feature_name STRING ,
feature_class STRING ,
state_alpha STRING,
prim_lat_dec DOUBLE ,
prim_long_dec DOUBLE ,
elev_in_ft BIGINT)

Versión de API 2012-08-10


1049
Amazon DynamoDB Guía para desarrolladores
Copia de datos en y desde Amazon DynamoDB

LOCATION 'hdfs:///user/hadoop/hive-test';

2. Copie los datos en DynamoDB.

INSERT OVERWRITE TABLE ddb_features


SELECT * FROM hdfs_features_unformatted;

Copia de datos con un formato especificado por el usuario


Si desea usar un carácter separador de campos distinto, puede crear una tabla externa que esté mapeada
al directorio de HDFS. Puede utilizar esta técnica para crear archivos de datos con valores separados por
comas (CSV).

Example De DynamoDB a HDFS

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.

CREATE EXTERNAL TABLE hdfs_features_csv


(feature_id BIGINT,
feature_name STRING ,
feature_class STRING ,
state_alpha STRING,
prim_lat_dec DOUBLE ,
prim_long_dec DOUBLE ,
elev_in_ft BIGINT)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
LOCATION 'hdfs:///user/hadoop/hive-test';

2. Copie los datos de DynamoDB.

INSERT OVERWRITE TABLE hdfs_features_csv


SELECT * FROM ddb_features;

El archivo de datos de HDFS tiene este aspecto:

920709,Soldiers Farewell Hill,Summit,NM,32.3564729,-108.3300461,6135


1178153,Jones Run,Stream,PA,41.2120086,-79.2592078,1260
253838,Sentinel Dome,Summit,CA,37.7229821,-119.58433,8133
264054,Neversweet Gulch,Valley,CA,41.6565269,-122.8361432,2900
115905,Chacaloochee Bay,Bay,AL,30.6979676,-87.9738853,0

Example De HDFS a DynamoDB

Con una sola instrucción de HiveQL, puede rellenar la tabla de DynamoDB usando los datos de HDFS:

INSERT OVERWRITE TABLE ddb_features


SELECT * FROM hdfs_features_csv;

Copia de datos sin mapeo de columnas


Puede copiar datos de DynamoDB en formato sin procesar y escribirlos en HDFS sin especificar ningún
tipo de datos ni mapeo de columnas. Puede utilizar este método para crear un archivo comprimido de los
datos de DynamoDB y almacenarlos en HDFS.

Versión de API 2012-08-10


1050
Amazon DynamoDB Guía para desarrolladores
Copia de datos en y desde Amazon DynamoDB

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.

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

CREATE EXTERNAL TABLE ddb_features_no_mapping


(item MAP<STRING, STRING>)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "Features");

2. Cree otra tabla externa asociada con el directorio de HDFS.

CREATE EXTERNAL TABLE hdfs_features_no_mapping


(item MAP<STRING, STRING>)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\t'
LINES TERMINATED BY '\n'
LOCATION 'hdfs:///user/hadoop/hive-test';

3. Copie los datos de DynamoDB a HDFS.

INSERT OVERWRITE TABLE hdfs_features_no_mapping


SELECT * FROM ddb_features_no_mapping;

El archivo de datos de HDFS tiene este aspecto:

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.

Example De HDFS a DynamoDB


Con una sola instrucción de HiveQL, puede rellenar la tabla de DynamoDB usando los datos de HDFS:

INSERT OVERWRITE TABLE ddb_features_no_mapping


SELECT * FROM hdfs_features_no_mapping;

Acceso a los datos de HDFS


HDFS es un sistema de archivos distribuido, accesible para todos los nodos del clúster de Amazon EMR.
Si usa SSH para conectarse al nodo de directriz, puede usar las herramientas de línea de comandos para
obtener acceso a los datos que Hive escribió en HDFS.

Versión de API 2012-08-10


1051
Amazon DynamoDB Guía para desarrolladores
Copia de datos en y desde Amazon DynamoDB

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.

hadoop fs -ls /user/hadoop/hive-test

El aspecto de la respuesta debe ser parecido al siguiente:

Found 1 items
-rw-r--r-- 1 hadoop hadoop 29504 2016-06-08 23:40 /user/hadoop/hive-test/000000_0

El nombre de archivo (000000_0) lo genera el sistema.


3. Visualice el contenido del archivo :

hadoop fs -cat /user/hadoop/hive-test/000000_0

Note

En este ejemplo, el archivo es relativamente pequeño (aproximadamente, 29 KB). Tenga


cuidado cuando utilice este comando con archivos que sean muy grandes o contengan
caracteres no imprimibles.
4. (Opcional) Puede copiar el archivo de datos de HDFS al sistema de archivos local en el nodo de
directriz. Después de hacerlo, puede utilizar las utilidades estándar de la línea de comandos de Linux
para trabajar con los datos del archivo.

hadoop fs -get /user/hadoop/hive-test/000000_0

Este comando no sobrescribirá el archivo.


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.

Uso de la compresión de datos


Cuando utilice Hive para copiar datos entre orígenes de datos diferentes, puede solicitar la compresión de
datos sobre la marcha. Hive proporciona varios códecs de compresión. Puede elegir uno de ellos durante
la sesión de Hive. Si lo hace, los datos se comprimirán en el formato especificado.

El siguiente ejemplo comprime los datos utilizando el algoritmo Lempel-Ziv-Oberhumer (LZO).

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;

CREATE EXTERNAL TABLE lzo_compression_table (line STRING)


ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t' LINES TERMINATED BY '\n'
LOCATION 's3://bucketname/path/subpath/';

INSERT OVERWRITE TABLE lzo_compression_table SELECT *


FROM hiveTableName;

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

Los códecs de compresión disponibles son:

• 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

Lectura de datos de caracteres UTF-8 no imprimibles


Para leer y escribir datos de caracteres UTF-8 no imprimibles, puede usar la herramientaSTORED AS
SEQUENCEFILEal crear una tabla Hive. Un SequenceFile es un formato de archivo binario de Hadoop.
Debe usar Hadoop para leer este archivo. En el siguiente ejemplo se muestra cómo exportar datos desde
DynamoDB a Amazon S3. Puede utilizar esta funcionalidad para controlar caracteres codificados con
UTF-8 no imprimibles.

CREATE EXTERNAL TABLE s3_export(a_col string, b_col bigint, c_col array<string>)


STORED AS SEQUENCEFILE
LOCATION 's3://bucketname/path/subpath/';

INSERT OVERWRITE TABLE s3_export SELECT *


FROM hiveTableName;

Ajuste del desempeño


Cuando se crea una tabla Hive externa mapeada a una tabla de DynamoDB, no se consume ninguna
capacidad de lectura o escritura de DynamoDB. Sin embargo, la actividad de lectura y escritura en la tabla
de Hive (por ejemplo,INSERTorSELECT) se convierte directamente en operaciones de lectura y escritura
en la tabla de DynamoDB subyacente.

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.

Versión de API 2012-08-10


1053
Amazon DynamoDB Guía para desarrolladores
Ajuste del desempeño

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)

Desempeño aprovisionado de DynamoDB


Cuando emita instrucciones HiveQL contra la tabla externa de DynamoDB,
elDynamoDBStorageHandlerrealiza las solicitudes apropiadas de API de DynamoDB de bajo nivel de,
que consumen desempeño provisionado. Si no hay suficiente capacidad de lectura o escritura en la tabla
de DynamoDB, se aplica una limitación limitada a la solicitud, lo que da lugar a un desempeño lento de
HiveQL. Por este motivo, debe asegurarse de que la tabla tenga suficiente capacidad de desempeño.

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:

21 474 836 480 / 409 600 = 52 429 segundos = 14,56 horas

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.

Es conveniente monitorizar periódicamente las métricas de CloudWatch correspondientes a la tabla.


Para obtener un resumen breve en la consola de DynamoDB, elija la tabla y, a continuación, seleccione
laMétricasPestaña. A partir de aquí, puede ver las unidades de capacidad de lectura y escritura
consumidas y las solicitudes de lectura y escritura que han sido objeto de una limitación controlada.

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.

Versión de API 2012-08-10


1054
Amazon DynamoDB Guía para desarrolladores
Ajuste del desempeño

El valor dedynamodb.throughput.read.percentpuede estar entre0.1y1.5, de manera


inclusiva.0.5representa la tasa de lectura predeterminada, lo que significa que Hive intentará consumir
la mitad de la capacidad de lectura de la tabla. Si aumenta el valor anterior0.5Hive aumentará la tasa
de solicitudes; disminuirá el valor por debajo de0.5Disminuye la tasa de solicitud de lectura. La tasa de
lectura real varía en función de diversos factores, tales como el hecho de que exista o no una distribución
uniforme de claves en la tabla de DynamoDB.

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.

El valor dedynamodb.throughput.write.percentpuede estar entre0.1y1.5, de manera


inclusiva.0.5representa la tasa de escritura predeterminada, lo que significa que Hive intentará consumir
la mitad de la capacidad de escritura de la tabla. Si aumenta el valor anterior0.5Hive aumentará la tasa
de solicitudes; disminuirá el valor por debajo de0.5Disminuye la tasa de solicitud de escritura. La tasa de
escritura real varía en función de diversos factores, tales como el hecho de que exista o no una distribución
uniforme de claves en la tabla de DynamoDB.

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

Ajuste de los mapeadores


Cuando Hive lanza un trabajo de Hadoop, lo procesan una o varias tareas de mapeador. Suponiendo
que la tabla de DynamoDB tenga suficiente capacidad de desempeño, puede modificar el número de
mapeadores del clúster, lo que podría mejorar el desempeño.

Versión de API 2012-08-10


1055
Amazon DynamoDB Guía para desarrolladores
Ajuste del desempeño

Note

El número de tareas de mapeador que se usan en un trabajo de Hadoop se ve incluido


porDivisión de entrada, donde Hadoop subdivide los datos en bloques lógicos. Si Hadoop no
realiza suficientes divisiones de entrada, entonces las operaciones de escritura podrían no
consumir todo el desempeño de escritura disponible en la tabla de DynamoDB.

Aumento del número de mapeadores


Cada mapeador de un Amazon EMR tiene una tasa de lectura máxima de 1 MiB por segundo. El número
de mapeadores del clúster depende del tamaño de los nodos que este contiene. Para obtener más
información sobre los tamaños de los nodos y el número de mapeadores por nodo, consulteConfiguración
de tareasen laGuía para desarrolladores de Amazon EMR.)

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.

Otra forma de aumentar el número de mapeadores es


modificarmapred.tasktracker.map.tasks.maximumParámetro de configuración de Hadoop. Se trata
de un parámetro de Hadoop, no de Hive. No puede modificarlo de forma interactiva desde el símbolo del
sistema. Si aumenta el valor demapred.tasktracker.map.tasks.maximumPuede incrementar el
número de mapeadores sin aumentar el número ni el tamaño de los nodos. Sin embargo, es posible que
los nodos del clúster se queden sin memoria si establece un valor demasiado elevado.

Establezca el valor demapred.tasktracker.map.tasks.maximumComo acción de arranque la


primera vez que lance el clúster de Amazon EMR. Para obtener más información, consulte(Opcional) Crear
acciones de arranque para instalar software adicionalen laGuía de administración de Amazon EMR.

Reducción del número de mapeadores


Si utiliza laSELECTPara seleccionar datos de una tabla de Hive externa mapeada a DynamoDB, el trabajo
de Hadoop puede utilizar tantas tareas como sea necesario, hasta el número máximo de mapeadores del
clúster. En este escenario, es posible que una consulta de Hive que tarde bastante en ejecutarse consuma
toda la capacidad de lectura provisionada de la tabla de DynamoDB, lo que afectaría negativamente a
otros usuarios.

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.

Versión de API 2012-08-10


1056
Amazon DynamoDB Guía para desarrolladores
Export to Amazon S3

Duración del intervalo de reintento


De forma predeterminada, Hive vuelve a ejecutar un trabajo de Hadoop si este no devuelve resultados
de DynamoDB en un plazo de dos minutos. Puede ajustar este intervalo modificando el parámetro
dynamodb.retry.duration:

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

Solicitudes de datos paralelas


Varias solicitudes de datos a una única tabla, ya sean de más de un usuario o de más de una aplicación,
podrían agotar el desempeño de lectura provisionado y ralentizar el desempeño.

Duración del proceso


La consistencia de datos en DynamoDB depende del orden de las operaciones de lectura y escritura en
cada nodo. Aunque haya una consulta de Hive en curso, otra aplicación podría cargar nuevos datos en la
tabla de DynamoDB o modificar o eliminar datos existentes. En este caso, los resultados de la consulta de
Hive podrían no reflejar los cambios realizados en los datos mientras se ejecutaba la consulta.

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.

Exportación de datos de tablas de DynamoDB a


Amazon S3
Mediante la exportación de tablas de DynamoDB, puede exportar datos de una tabla de Amazon
DynamoDB desde cualquier momento dentro de su ventana de recuperación puntual a un bucket de
Amazon S3. La exportación de una tabla de DynamoDB a un bucket de S3 le permite realizar análisis
y consultas complejas en sus datos mediante otrosAWSservicios como Athena,AWS Glue, y Lake
Formation. La exportación de tablas de DynamoDB es una solución totalmente administrada para exportar
tablas de DynamoDB a escala y es mucho más rápida que otras soluciones alternativas que implican
análisis de tablas. Para obtener más información, consulte Exportación de datos de DynamoDB a Amazon
S3: cómo funciona (p. 1058).

La exportación de una tabla no consume capacidad de lectura en la tabla y no afecta el rendimiento y la


disponibilidad de la tabla. Puede exportar datos de tabla a un bucket S3 propiedad de otroAWSy a una
región diferente a la de la de su tabla. Sus datos siempre están cifrados de extremo a extremo.

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.

Versión de API 2012-08-10


1057
Amazon DynamoDB Guía para desarrolladores
Cómo funciona

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)

Exportación de datos de DynamoDB a Amazon S3:


cómo funciona
Para exportar datos de una tabla de Amazon DynamoDB a un bucket de Amazon S3, la recuperación a
un momento dado (PITR) debe estar activada en la tabla de origen. Puede exportar datos de tabla desde
cualquier punto en el tiempo dentro de la ventana PITR, hasta 35 días. Para obtener más información,
consulte Recuperación a un momento dado para DynamoDB (p. 715).

La exportación de una tabla no consume capacidad de lectura en la tabla y no afecta el rendimiento y la


disponibilidad de la tabla. Puede exportar datos de tabla a un bucket S3 propiedad de otroAWSy a una
región diferente a la de la de su tabla. Sus datos siempre están cifrados en reposo y en tránsito.

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.

Solicitar una exportación de tabla en DynamoDB


Las exportaciones de tablas de DynamoDB le permiten exportar datos de tabla a un bucket de Amazon
S3, lo que le permite realizar análisis y consultas complejas sobre sus datos mediante otrosAWSservicios
como Athena,AWS Glue, y Lake Formation. Puede solicitar una exportación de tabla mediante la
herramientaAWS Management Console, elAWS CLIo la API de DynamoDB.

Versión de API 2012-08-10


1058
Amazon DynamoDB Guía para desarrolladores
Solicitud de una exportación

Note

La exportación de tablas de DynamoDB solo está disponible en el nuevoAWS Management


ConsoleVista de. Si aún no está utilizando la nueva consola, busque el enlace «Probar la nueva
consola» en la barra lateral de navegación.

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)

Configuración y permisos de Amazon S3


Puede exportar los datos de la tabla a cualquier depósito de Amazon S3 en el que tenga permiso
para escribir. El bucket de destino no necesita estar en la misma región ni tener el mismo
propietario que la tabla de origen. SusAWS Identity and Access Management(IAM) debería permitir
que els3:AbortMultipartUpload,s3:PutObject, ys3:PutObjectAcl, además de las
accionesdynamodb:ExportTableToPointInTime, como se muestra en el ejemplo siguiente.

{
"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/*"

Versión de API 2012-08-10


1059
Amazon DynamoDB Guía para desarrolladores
Solicitud de una exportación

}
]
}

El siguiente código es un ejemplo de política de bucket de S3 (en la cuenta de destino).

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

Solicitar una exportación mediante elAWS Management Console


En el siguiente ejemplo, se ilustra cómo utilizar la consola de DynamoDB para exportar una tabla existente
denominadaMusicCollection.
Note

En este procedimiento se presupone que ha habilitado la recuperación a un momento dado. Para


habilitarlo para elMusicCollection, en la tablaInformación general, en la pestañaDetalles de la
tabla, elija.Habilitar: paraRecuperación a un momento dado.

Para solicitar una exportación de tabla

1. Inicie sesión en laAWS Management Consoley abra la consola de DynamoDB enhttps://


console.aws.amazon.com/dynamodb/.
2. En el panel de navegación del lado izquierdo de la consola, elijaExportaciones y flujos.
3. En la páginaExportaciones, elija.Export to S3.
4. Elija una tabla de origen y un bucket de S3 de destino. Si el bucket de desinación es propiedad de su
cuenta, puede utilizar laExaminar S3para encontrarlo. En caso contrario, escriba la URL del bucket
con el comandos3://bucketname/prefix format.elprefixes una carpeta opcional para
ayudar a mantener el cubo de desinación organizado.
5. De forma predeterminada, la tabla se exportará en formato JSON de DynamoDB a partir del último
momento restaurable en la ventana de recuperación a un momento dado y se cifrará con una clave
de Amazon S3 (SSE-S3). Si desea cambiar esta configuración, expanda laAjustes adicionalesde la
página e introduzca la configuración de exportación que desee.
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.
6. Haga clic en el botón .Exportpara comenzar la exportación.

Versión de API 2012-08-10


1060
Amazon DynamoDB Guía para desarrolladores
Solicitud de una exportación

Obtención de detalles sobre exportaciones pasadas en elAWS


Management Console
Puede encontrar información sobre las tareas de exportación que ha ejecutado en el pasado haciendo
clic enExportaciones y flujosen la barra lateral de navegación y, a continuación, seleccione la
opciónExportacionesPestaña. Esta pestaña contiene una lista de todas las exportaciones que ha creado
en los últimos 90 días. Al seleccionar el ARN de una tarea enumerada en la ficha Exportaciones, se
recuperará información sobre esa exportación, incluida la configuración avanzada que haya elegido. Tenga
en cuenta que aunque los metadatos de la tarea de exportación caducan después de 90 días y los trabajos
anteriores ya no se encuentran en esta lista, los objetos del depósito de S3 permanecen siempre que
lo permitan sus políticas de depósito. DynamoDB nunca elimina ninguno de los objetos que crea en su
depósito de S3 durante una exportación.

Solicitar una exportación mediante elAWS CLI


En el siguiente ejemplo se muestra cómo utilizar laAWS CLIpara exportar una tabla existente
denominadaMusicCollectiona un bucket de S3 denominadoddb-export-musiccollection.
Note
En este procedimiento se presupone que ha habilitado la recuperación a un momento dado. Para
habilitarlo en la tabla MusicCollection, ejecute el siguiente comando.

aws dynamodb update-continuous-backups \


--table-name MusicCollection \
--point-in-time-recovery-specification PointInTimeRecoveryEnabled=True

El siguiente comando exporta elMusicCollectiona un bucket de S3 denominadoddb-export-


musiccollectioncon un prefijo de2020-Nov. Los datos de tabla se exportarán en formato JSON de
DynamoDB desde un momento dado dentro de la ventana de recuperación a un momento dado y se
cifrarán con una clave de Amazon S3 (SSE-S3).

aws dynamodb export-table-to-point-in-time \


--table-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
--s3-bucket ddb-export-musiccollection \
--s3-prefix 2020-Nov \
--export-format DYNAMODB_JSON \
--export-time 1604632434 \
--s3-sse-algorithm AES256

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.

Obtención de detalles sobre exportaciones pasadas en elAWS


CLI
Puede encontrar información acerca de las tareas de exportación que ha ejecutado en el pasado mediante
ellist-exportsEl comando de. Este comando devuelve una lista de todas las exportaciones que ha
creado en los últimos 90 días. Tenga en cuenta que aunque los metadatos de la tarea de exportación
caducan después de 90 días y los trabajos anteriores ya no son devueltos por ellist-exports, los
objetos del depósito de S3 permanecen mientras lo permitan sus políticas de depósito. DynamoDB nunca
elimina ninguno de los objetos que crea en su depósito de S3 durante una exportación.

En el siguiente ejemplo, utilizamos la opcióntable-arnpara enumerar sólo las exportaciones de una tabla
específica.

Versión de API 2012-08-10


1061
Amazon DynamoDB Guía para desarrolladores
Export output

aws dynamodb list-exports \


--table-arn arn:aws:dynamodb:us-east-1:123456789012:table/ProductCatalog

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.

aws dynamodb describe-export \


--export-arn arn:aws:dynamodb:us-east-1:123456789012:table/ProductCatalog/
export/01234567890123-a1b2c3d4

Formato de salida de exportación de tabla de Dynamo


Una exportación de tabla de DynamoDB incluye dos archivos de manifiesto además de los archivos
que contienen los datos de la tabla. Todos estos archivos se guardan en el bucket de Amazon S3 que
especifique en suSolicitud de exportación (p. 1058). En las secciones siguientes se describen los formatos
y contenidos de cada objeto de salida.

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",

Versión de API 2012-08-10


1062
Amazon DynamoDB Guía para desarrolladores
Export output

"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"
},

Versión de API 2012-08-10


1063
Amazon DynamoDB Guía para desarrolladores
Export output

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

Conversión de tipo de datos de DynamoDB a Ion

Tipo de dato de DynamoDB Representación Ion

Cadena (S) string

Booleano (BOOL) bool

número (N) decimal

binario (B) blob

Juego (SS, NS, BS) lista (con anotación de tipo $DynamoDB_SS,


$DynamoDB_NS o $DynamoDB_BS)

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",

Versión de API 2012-08-10


1064
Amazon DynamoDB Guía para desarrolladores
Uso de las exportaciones con otros servicios

Id:103.,
InPublication:false,
PageCount:6d2,
Price:2d3,
ProductCategory:"Book",
Title:"Book 103 Title"
}
}

Uso de exportaciones de tablas de DynamoDB con


otrosAWSservices
Una vez que los datos de la tabla de DynamoDB se exportan a Amazon S3, puede procesarlos desde una
variedad de otrosAWSServicios de . En las secciones siguientes se detallan algunas de las opciones para
consultar los datos exportados.

Uso de las exportaciones con Amazon Athena


Amazon Athena es un servicio de consultas interactivo que facilita el análisis de datos en Amazon S3 con
SQL estándar. Athena no requiere un servidor, por lo que no hay que administrar ninguna infraestructura y
solo pagará por las consultas que ejecute. Para obtener más información, consulte laGuía del usuario de
Amazon Athena.

Uso de las exportaciones conAWS Glue


AWS Gluees un servicio totalmente administrado de extracción, transformación y carga (ETL) que facilita
la carga de datos para su análisis. Puede crear y ejecutar un trabajo ETL con unos pocos clics en el
cuadro de diálogoAWS Glueeditor visual. Simplemente apuntaAWS GluePara obtener información sobre
sus datos yAWS Gluedescubre los datos y almacena los metadatos asociados (como la definición de
tabla y el esquema) en elAWS Glue Data Catalog. Una vez catalogados, sus datos se pueden buscar
inmediatamente, consultar y estar disponibles para ETL. Para obtener más información, consulte AWS
Glue Developer Guide.

Uso de las exportaciones conAWS Lake Formation


AWS Lake Formationhace que sea fácil configurar un lago de datos seguro en días. Un lago de datos es
un repositorio centralizado, comisariado y seguro que almacena todos los datos, tanto en su forma original
como preparado para su análisis. Un lago de datos le permite desglosar los silos de datos y combinar
diferentes tipos de análisis para obtener información y guiar mejores decisiones empresariales.

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.

Versión de API 2012-08-10


1065
Amazon DynamoDB Guía para desarrolladores
Modo de capacidad de lectura/escritura y rendimiento

Cuotas de servicio, cuenta y tabla en


Amazon DynamoDB
En esta sección se describen las cuotas actuales de Amazon DynamoDB (o ninguna cuota, en algunos
casos). Cada una de las cuotas se aplica a una sola región, a no ser que se especifique otra cosa.

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)

Modo de capacidad de lectura/escritura y


rendimiento
Puede cambiar entre los modos de capacidad de lectura/escritura una vez cada 24 horas.

Tamaños de las unidades de capacidad (para las


tablas aprovisionadas)
Una unidad de capacidad de lectura equivale a una lectura de consistencia alta por segundo, o bien a dos
lecturas consistentes posteriores por segundo, para elementos con un tamaño de hasta 4 KB.

Una unidad de capacidad de escritura equivale a una escritura por segundo para los elementos con un
tamaño de hasta 1 KB.

Versión de API 2012-08-10


1066
Amazon DynamoDB Guía para desarrolladores
Tamaños de las unidades de solicitud
(para las tablas bajo demanda)

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.

Tamaños de las unidades de solicitud (para las tablas


bajo demanda)
Una unidad de solicitud de lectura equivale a una lectura de consistencia alta, o bien a dos lecturas
consistentes posteriores, para elementos con un tamaño de hasta 4 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.

Cuotas de rendimiento predeterminadas


AWSestablece algunas cuotas predeterminadas respecto al rendimiento que se puede aprovisionar. 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.

  Bajo demanda Aprovisionada

Per table 40,000 read request 40,000 read capacity


units and 40,000 write units and 40,000 write
request units capacity units

Per account Not applicable 80,000 read capacity


units and 80,000 write
capacity units

Minimum throughput for Not applicable 1 read capacity unit and


any table or global 1 write capacity unit
secondary index

Note

Todo el rendimiento disponible para la cuenta se puede aplicar a una sola tabla o a varias tablas.

La cuota de rendimiento aprovisionado incluye la suma de la capacidad de la tabla y de la capacidad de


todos sus índices secundarios globales.

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.

Si ha aumentado las cuotas predeterminadas de rendimiento aprovisionado, puede usar la operación


DescribeLimits para consultar los valores actuales de las cuotas.

Versión de API 2012-08-10


1067
Amazon DynamoDB Guía para desarrolladores
Aumento o reducción del rendimiento
(en las tablas aprovisionadas)

Aumento o reducción del rendimiento (en las tablas


aprovisionadas)
Aumento de rendimiento aprovisionado
Puede aumentar el valor de ReadCapacityUnits o WriteCapacityUnits con tanta frecuencia como
sea preciso; para ello, puede usar la AWS Management Console o la operación UpdateTable. En una
sola llamada, puede aumentar el rendimiento aprovisionado de una tabla, de cualquier índice secundario
global de esa tabla o de cualquier combinación de ellos. La nueva configuración no surtirá efecto hasta que
se haya completado la operación UpdateTable.

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

Reducción de rendimiento aprovisionado


En cada tabla e índice secundario global de una operación UpdateTable, puede reducir el valor de
ReadCapacityUnits, de WriteCapacityUnits o de ambas opciones. La nueva configuración no
surtirá efecto hasta que se haya completado la operación UpdateTable. Se puede reducir la capacidad
hasta cuatro veces al día. Un día se define según la hora universal coordinada (UTC). Además, si no ha
habido ninguna reducción en la última hora, se permite una reducción adicional. Esto aumenta el número
máximo de reducciones a al día 27 (4 en la primera hora y 1 en cada hora posterior).
Important

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:

• Reduzca los valores WriteCapacityUnits o ReadCapacityUnits (o ambos) cuatro veces.


• Reduzca los valores WriteCapacityUnits o ReadCapacityUnits (o ambos) del índice secundario
global cuatro veces.

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.

Versión de API 2012-08-10


1068
Amazon DynamoDB Guía para desarrolladores
Tablas por cuenta

Tablas por cuenta


Para cualquierAWS, existe una cuota inicial de 256 tablas porAWSRegión .

Para solicitar un aumento de la cuota de servicio, consultehttps://aws.amazon.com/support.

Tablas globales
AWSExamine algunas cuotas predeterminadas en el rendimiento que puede aprovisionar o utilizar al usar
tablas globales.

  Bajo demanda Aprovisionada

Per table 40,000 read request 40,000 read capacity


units and 40,000 write units and 40,000 write
request units capacity units

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.

Las operaciones transaccionales proporcionan garantías de atomicidad, uniformidad, aislamiento y


durabilidad (ACID) solo en elAWSRegión en la que se hace originalmente la escritura. No se admiten
las transacciones entre regiones en las tablas globales. Por ejemplo, supongamos que tiene una
tabla global con réplicas en las regiones EE. UU. Este (Ohio) y EE. UU. Oeste (Oregón) y realiza una
operación TransactWriteItems en la región EE. UU. Este (Norte de Virginia). En este caso, puede observar
transacciones parcialmente completadas en la región EE. UU. Oeste (Oregón) a medida que se replican
los cambios. Los cambios se replican en otras regiones solo cuando se han confirmado en la región de
origen.

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

Puede crear o eliminar solo un índice secundario global porUpdateTable.

Atributos de índice secundario proyectados por tabla


Puede proyectar un máximo de 100 atributos en todos los índices secundarios locales y globales de una
tabla. Esto solo se aplica a los atributos proyectados especificados por el usuario.

En unCreateTable, si especifica unaProjectionTypedeINCLUDE, el recuento total de atributos


especificados enNonKeyAttributes, sumado en todos los índices secundarios, no debe ser mayor que

Versión de API 2012-08-10


1069
Amazon DynamoDB Guía para desarrolladores
Claves de partición y claves de ordenación

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.

Claves de partición y claves de ordenación


Longitud de la clave de partición
La longitud mínima de un valor de clave de partición es de 1 byte. La longitud máxima es de 2048 bytes.

Valores de clave de partición


No existe ningún límite práctico respecto al número de valores diferentes de clave de partición, ni para
tablas ni para los índices secundarios.

Longitud de la clave de ordenación


La longitud mínima de un valor de clave de ordenación es de 1 byte. La longitud máxima es de 1024 bytes.

Valores de clave de ordenación


En general, no existe ningún límite práctico respecto al número de valores diferentes de clave de
ordenación por cada valor de clave de partición.

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)

Nombres de los atributos


En general, un nombre de atributo debe tener un carácter como mínimo y su tamaño máximo no debe
superar los 64 KB.

Versión de API 2012-08-10


1070
Amazon DynamoDB Guía para desarrolladores
Tipos de datos

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 del índice secundario
• Los nombres de los atributos proyectados especificados por el usuario (aplicables solo a los índices
secundarios locales). En una operación CreateTable, si especifica el valor ProjectionType
para INCLUDE, los nombres de los atributos del parámetro NonKeyAttributes estarán sujetos a
restricciones de longitud. Los tipos de proyecciones KEYS_ONLY y ALL no se ven afectados.

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.

• Rango de valores positivos: de 1E-130 a 9.9999999999999999999999999999999999999E+125


• Rango de valores negativos: de -9.9999999999999999999999999999999999999E+125 a -1E-130

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.

Versión de API 2012-08-10


1071
Amazon DynamoDB Guía para desarrolladores
Tamaño del elemento para tablas
con índices secundarios locales

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.

Tamaño del elemento para tablas con índices


secundarios locales
Para cada índice secundario local de una tabla, existe un límite de 400 KB respecto al total de los
siguientes índices:

• El tamaño de los datos de un elemento de la tabla.


• El tamaño de la entrada del índice secundario local correspondiente a dicho elemento, incluidos sus
valores de clave y atributos proyectados.

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

Número de valores de una lista, un mapa o un


conjunto
No existe ningún límite respecto al número de valores de una lista, un mapa o un conjunto, siempre y
cuando el elemento que contenga los valores se ajuste al límite de tamaño de elemento de 400 KB.

Valores de los atributos


Se pueden emplear valores de atributo binarios o de cadena vacíos si el atributo no se utiliza como atributo
de clave en una tabla o índice. En los conjuntos, listas y mapas, se admiten valores binarios y de cadena
vacíos. 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 admiten valores de tipo lista o mapa vacíos.

Profundidad de los atributos anidados


DynamoDB admite atributos anidados de hasta 32 niveles de profundidad.

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.

Versión de API 2012-08-10


1072
Amazon DynamoDB Guía para desarrolladores
Operadores y operandos

La longitud máxima de cualquier nombre de atributo de expresión individual o valor de atributo de


expresión es de 255 bytes. Por ejemplo, en el caso de #name, es de 5 bytes, mientras que en el de :val,
es de 4.

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 “+”.

La cantidad máxima de operandos del comparador IN es de 100.

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:

• Una transacción no puede contener más de 25 elementos únicos.


• Una transacción no puede contener más de 4 MB de datos.
• No se pueden aplicar dos acciones de una transacción al mismo elemento de la misma tabla. Por
ejemplo, no se puede usar ConditionCheck y Update para el mismo elemento de una transacción.
• Una transacción no puede operar en tablas en más de unAWScuenta o Región.
• Las operaciones transaccionales proporcionan garantías de atomicidad, uniformidad, aislamiento y
durabilidad (ACID) solo en elAWSRegión en la que se hace originalmente la escritura. No se admiten
las transacciones entre regiones en las tablas globales. Por ejemplo, supongamos que tiene una
tabla global con réplicas en las regiones EE. UU. Este (Ohio) y EE. UU. Oeste (Oregón) y realiza una
operación TransactWriteItems en la región EE. UU. Este (Norte de Virginia). En este caso, puede
observar transacciones parcialmente completadas en la región EE. UU. Oeste (Oregón) a medida que
se replican los cambios. Los cambios se replican en otras regiones solo cuando se han confirmado en la
región de origen.

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.

Versión de API 2012-08-10


1073
Amazon DynamoDB Guía para desarrolladores
Capacidad de escritura máxima
de una tabla con un flujo habilitado

Capacidad de escritura máxima de una tabla con un


flujo habilitado
AWSAWS establece algunas cuotas predeterminadas respecto a la capacidad de escritura de las tablas
de DynamoDB Streams habilitados DynamoDB Streams. 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.

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

DynamoDB Accelerator (DAX)


Disponibilidad por región de AWS
Para obtener una lista deAWSLas regiones en las que DAX está disponible, consulteDynamoDB
Accelerator (DAX)en laAWSReferencia general de.

Nodes
Un clúster de DAX consta exactamente de un nodo principal y entre cero y diez nodos de réplica de
lectura.

El número total de nodos (porAWS) no puede exceder de 50 en una solaAWSRegión .

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.

Dentro de un grupo de subredes, puede definir hasta 20 subredes.

Versión de API 2012-08-10


1074
Amazon DynamoDB Guía para desarrolladores
Límites específicos de API

Límites específicos de API


CreateTable/UpdateTable/DeleteTable

En general, puede haber hasta 50CreateTable,UpdateTable, yDeleteTableLas solicitudes se


ejecutan simultáneamente (en cualquier combinación). Es decir, el número total de tablas que se
encuentren en estado CREATING, UPDATING o DELETING no puede ser mayor que 50.

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

Un soloBatchGetItemLa operación puede recuperar un máximo de 100 elementos. El tamaño total


de todos los elementos recuperados no puede ser mayor que 16 MB.

BatchWriteItem

Un soloBatchWriteItemLa operación puede contener hasta 25PutItemorDeleteItemsolicitudes


de. El tamaño total de todos los elementos escritos no puede ser mayor que 16 MB.

DescribeTableReplicaAutoScaling

El método DescribeTableReplicaAutoScaling admite solo diez solicitudes por segundo.

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

Solo se debe llamar a DescribeContributorInsights, ListContributorInsights y


UpdateContributorInsights de forma periódica. DynamoDB admite hasta cinco solicitudes por
segundo para cada una de estas API.

Query

El conjunto de resultados de unQueryestá limitado a 1 MB por llamada. Puede utilizar


LastEvaluatedKey de la respuesta a la consulta para recuperar más resultados.

Scan

El conjunto de resultados de unScanestá limitado a 1 MB por llamada. Puede utilizar


LastEvaluatedKey de la respuesta al examen para recuperar más resultados.

UpdateTableReplicaAutoScaling

UpdateTableReplicaAutoScalingadmite solo diez solicitudes por segundo.

Versión de API 2012-08-10


1075
Amazon DynamoDB Guía para desarrolladores
DynamoDB ado en reposo

DynamoDB ado en reposo


Puede cambiar entre un valor de tipoAWSclave maestra del cliente propiedad (CMK), una clave maestra
de clienteAWSCon un CMK administrado por un cliente hasta cuatro veces cada 24 horas por cada tabla,
a partir del momento en el que se cree la tabla. En caso de no producirse ningún cambio en las últimas
horas, se permite un cambio adicional. Esto aumenta el número máximo de cambios a ocho al día (cuatro
cambios en las primeras seis horas y uno en cada una de las seis horas posteriores).

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.

Exportación de tablas a Amazon S3


Se pueden exportar simultáneamente hasta 300 tareas de exportación o hasta 100 TB de tamaño de tabla.

Versión de API 2012-08-10


1076
Amazon DynamoDB Guía para desarrolladores

Referencia de API de bajo nivel


La Referencia de la API de Amazon DynamoDB contiene una lista completa de las operaciones admitidas
por:

• DynamoDB.
• DynamoDB Streams .
• DynamoDB Accelerator (DAX).

Versión de API 2012-08-10


1077
Amazon DynamoDB Guía para desarrolladores
Solución de problemas de establecimiento
de conexiones SSL/TLS de

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)

Solución de problemas de establecimiento de


conexiones SSL/TLS de
Amazon DynamoDB está moviendo nuestros extremos a certificados seguros firmados por la autoridad de
certificación de Amazon Trust Services (ATS) en lugar de una entidad emisora de certificados de terceros.
En diciembre de 2017, lanzamos la región EU-WEST-3 (París) con los certificados seguros emitidos por
Amazon Trust Services. Todas las nuevas regiones lanzadas después de diciembre de 2017 tienen puntos
finales con los certificados emitidos por Amazon Trust Services. En esta guía se explica cómo validar y
solucionar los problemas de conexión SSL/TLS.

Probar su aplicación o servicio


La mayoría deAWSLos SDK y las interfaces de línea de comandos (CLI) admiten la autoridad de
certificación de Amazon Trust Services. Si utiliza una versión de laAWSSDK para Python o CLI publicado
antes del 29 de octubre de 2013, debe actualizar. Los SDK y CLI de.NET, Java, PHP, Go, JavaScript y C
++ no agrupan ningún certificado, sus certificados provienen del sistema operativo subyacente. El SDK de
Ruby ha incluido al menos una de las CA necesarias desde el 10 de junio de 2015. Antes de esa fecha, el
SDK de Ruby V2 no incluía certificados. Si utiliza una versión no compatible, personalizada o modificada
delAWSSDK, o si utiliza un almacén de confianza personalizado, es posible que no cuente con el soporte
necesario para la Autoridad de certificados de Amazon Trust Services.

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:

Versión de API 2012-08-10


1078
Amazon DynamoDB Guía para desarrolladores
Probar el navegador del cliente

• Errores de negociación SSL/TLS


• Un largo retraso antes de que el software reciba un error que indica un error de negociación SSL/TLS.
El tiempo de retardo depende de la estrategia de reintento y la configuración del tiempo de espera de su
cliente.

Probar el navegador del cliente


Para comprobar que su navegador puede conectarse a Amazon DynamoDB, abra la siguiente dirección
URL:https://dynamodb.eu-west-3.amazonaws.com. Si la prueba se realiza correctamente, aparecerá un
mensaje como este:

healthy: dynamodb.eu-west-3.amazonaws.com

Si la prueba no tiene éxito, mostrará un error similar al siguiente:https://untrusted-root.badssl.com/.

Actualización del cliente de aplicación de software


Si las aplicaciones que obtengan acceso a los puntos de enlace de la API de Streams DynamoDB o
DynamoDB (ya sea a través de un navegador o mediante programación) deberán actualizar la lista de
entidades de certificación de confianza en los equipos cliente si no admiten ninguna de las siguientes
entidades de certificación:

• 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/.

Actualizar el navegador del cliente


Puede actualizar el paquete de certificados en su navegador simplemente actualizando su navegador.
Las instrucciones para los navegadores más comunes se pueden encontrar en los sitios web de los
navegadores:

• 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

Actualización manual del paquete de certificados


Si no puede acceder a la API de DynamoDB o la API de DynamoDB Streams, deberá actualizar el paquete
de certificados. Para ello, debe importar al menos una de las CA requeridas. Puede encontrarlos enhttps://
www.amazontrust.com/repository/.

Versión de API 2012-08-10


1079
Amazon DynamoDB Guía para desarrolladores
Ejemplos de tablas y datos

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.

Ejemplos de tablas y datos


LaGuía para desarrolladores de Amazon DynamoDBEn la se utilizan ejemplos de tablas para ilustrar
diversos aspectos de DynamoDB.

Nombre de la tabla Clave principal

ProductCatalog Clave principal simple:

• Id (Número)

Forum Clave principal simple:

• Name (Cadena)

Thread Clave principal compuesta:

• ForumName (Cadena)
• Subject (Cadena)

Responder Clave principal compuesta:

• Id (Cadena)
• ReplyDateTime (Cadena)

LaResponderLa tabla tiene un índice secundario global llamadoPostedBy-Message-Index. Este índice


facilitará las consultas de dos atributos sin clave de la tabla Reply.

Nombre de índice Clave principal

PostedBy-Message-Index Clave principal compuesta:

• PostedBy (Cadena)
• Message (Cadena)

Versión de API 2012-08-10


1080
Amazon DynamoDB Guía para desarrolladores
Ejemplos de archivos de datos

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

Ejemplos de archivos de datos


Temas
• ProductCatalogDatos de ejemplo (p. 1081)
• ForumDatos de ejemplo (p. 1086)
• ThreadDatos de ejemplo (p. 1086)
• ReplyDatos de ejemplo (p. 1088)

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"
}
}

Versión de API 2012-08-10


1081
Amazon DynamoDB Guía para desarrolladores
Ejemplos de archivos de datos

}
},
{
"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"

Versión de API 2012-08-10


1082
Amazon DynamoDB Guía para desarrolladores
Ejemplos de archivos de datos

},
"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": {

Versión de API 2012-08-10


1083
Amazon DynamoDB Guía para desarrolladores
Ejemplos de archivos de datos

"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": {

Versión de API 2012-08-10


1084
Amazon DynamoDB Guía para desarrolladores
Ejemplos de archivos de datos

"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"
}

Versión de API 2012-08-10


1085
Amazon DynamoDB Guía para desarrolladores
Ejemplos de archivos de datos

}
}
}
]
}

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"

Versión de API 2012-08-10


1086
Amazon DynamoDB Guía para desarrolladores
Ejemplos de archivos de datos

},
"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"
},

Versión de API 2012-08-10


1087
Amazon DynamoDB Guía para desarrolladores
Ejemplos de archivos de datos

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

Versión de API 2012-08-10


1088
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos

},
"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"
}
}
}
}
]
}

Creación de ejemplos de tablas y carga de datos


Temas
• Creación de ejemplos de tablas y carga de datos mediante la.AWS SDK for Java (p. 1090)
• Creación de ejemplos de tablas y carga de datos mediante la.AWS SDK for .NET (p. 1097)

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

Versión de API 2012-08-10


1089
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos: Java

a las tablas. En este apéndice se proporciona código para crear las tablas y agregarles datos mediante
programación.

Creación de ejemplos de tablas y carga de datos


mediante la.AWS SDK for Java
En el siguiente ejemplo de código Java se crean tablas y se cargan datos en ellas. La estructura de tablas
y los datos resultantes se muestran en.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 ejecutar este código mediante
Eclipse, 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;

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;

public class CreateTablesLoadData {

static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();


static DynamoDB dynamoDB = new DynamoDB(client);

static SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-


dd'T'HH:mm:ss.SSS'Z'");

static String productCatalogTableName = "ProductCatalog";


static String forumTableName = "Forum";
static String threadTableName = "Thread";
static String replyTableName = "Reply";

Versión de API 2012-08-10


1090
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos: Java

public static void main(String[] args) throws Exception {

try {

deleteTable(productCatalogTableName);
deleteTable(forumTableName);
deleteTable(threadTableName);
deleteTable(replyTableName);

// Parameter1: table name


// Parameter2: reads per second
// Parameter3: writes per second
// Parameter4/5: partition key and data type
// Parameter6/7: sort key and data type (if applicable)

createTable(productCatalogTableName, 10L, 5L, "Id", "N");


createTable(forumTableName, 10L, 5L, "Name", "S");
createTable(threadTableName, 10L, 5L, "ForumName", "S", "Subject", "S");
createTable(replyTableName, 10L, 5L, "Id", "S", "ReplyDateTime", "S");

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

private static void deleteTable(String tableName) {


Table table = dynamoDB.getTable(tableName);
try {
System.out.println("Issuing DeleteTable request for " + tableName);
table.delete();
System.out.println("Waiting for " + tableName + " to be deleted...this may take
a while...");
table.waitForDelete();

}
catch (Exception e) {
System.err.println("DeleteTable request failed for " + tableName);
System.err.println(e.getMessage());
}
}

private static void createTable(String tableName, long readCapacityUnits, long


writeCapacityUnits,
String partitionKeyName, String partitionKeyType) {

createTable(tableName, readCapacityUnits, writeCapacityUnits, partitionKeyName,


partitionKeyType, null, null);
}

private static void createTable(String tableName, long readCapacityUnits, long


writeCapacityUnits,
String partitionKeyName, String partitionKeyType, String sortKeyName, String
sortKeyType) {

try {

ArrayList<KeySchemaElement> keySchema = new ArrayList<KeySchemaElement>();

Versión de API 2012-08-10


1091
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos: Java

keySchema.add(new
KeySchemaElement().withAttributeName(partitionKeyName).withKeyType(KeyType.HASH)); //
Partition

// key

ArrayList<AttributeDefinition> attributeDefinitions = new


ArrayList<AttributeDefinition>();
attributeDefinitions
.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));
}

CreateTableRequest request = new


CreateTableRequest().withTableName(tableName).withKeySchema(keySchema)
.withProvisionedThroughput(new
ProvisionedThroughput().withReadCapacityUnits(readCapacityUnits)
.withWriteCapacityUnits(writeCapacityUnits));

// If this is the Reply table, define a local secondary index


if (replyTableName.equals(tableName)) {

attributeDefinitions
.add(new
AttributeDefinition().withAttributeName("PostedBy").withAttributeType("S"));

ArrayList<LocalSecondaryIndex> localSecondaryIndexes = new


ArrayList<LocalSecondaryIndex>();
localSecondaryIndexes.add(new
LocalSecondaryIndex().withIndexName("PostedBy-Index")
.withKeySchema(new
KeySchemaElement().withAttributeName(partitionKeyName).withKeyType(KeyType.HASH), //
Partition

// key
new
KeySchemaElement().withAttributeName("PostedBy").withKeyType(KeyType.RANGE)) // Sort

// key
.withProjection(new
Projection().withProjectionType(ProjectionType.KEYS_ONLY)));

request.setLocalSecondaryIndexes(localSecondaryIndexes);
}

request.setAttributeDefinitions(attributeDefinitions);

System.out.println("Issuing CreateTable request for " + tableName);


Table table = dynamoDB.createTable(request);
System.out.println("Waiting for " + tableName + " to be created...this may take
a while...");
table.waitForActive();

}
catch (Exception e) {
System.err.println("CreateTable request failed for " + tableName);
System.err.println(e.getMessage());

Versión de API 2012-08-10


1092
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos: Java

}
}

private static void loadSampleProducts(String tableName) {

Table table = dynamoDB.getTable(tableName);

try {

System.out.println("Adding data to " + tableName);

Item item = new Item().withPrimaryKey("Id", 101).withString("Title", "Book 101


Title")
.withString("ISBN", "111-1111111111")
.withStringSet("Authors", new
HashSet<String>(Arrays.asList("Author1"))).withNumber("Price", 2)
.withString("Dimensions", "8.5 x 11.0 x 0.5").withNumber("PageCount", 500)
.withBoolean("InPublication", true).withString("ProductCategory", "Book");
table.putItem(item);

item = new Item().withPrimaryKey("Id", 102).withString("Title", "Book 102


Title")
.withString("ISBN", "222-2222222222")
.withStringSet("Authors", new HashSet<String>(Arrays.asList("Author1",
"Author2")))
.withNumber("Price", 20).withString("Dimensions", "8.5 x 11.0 x
0.8").withNumber("PageCount", 600)
.withBoolean("InPublication", true).withString("ProductCategory", "Book");
table.putItem(item);

item = new Item().withPrimaryKey("Id", 103).withString("Title", "Book 103


Title")
.withString("ISBN", "333-3333333333")
.withStringSet("Authors", new HashSet<String>(Arrays.asList("Author1",
"Author2")))
// Intentional. Later we'll run Scan to find price error. Find
// items > 1000 in price.
.withNumber("Price", 2000).withString("Dimensions", "8.5 x 11.0 x
1.5").withNumber("PageCount", 600)
.withBoolean("InPublication", false).withString("ProductCategory", "Book");
table.putItem(item);

// Add bikes.

item = new Item().withPrimaryKey("Id", 201).withString("Title", "18-Bike-201")


// Size, followed by some title.
.withString("Description", "201 Description").withString("BicycleType",
"Road")
.withString("Brand", "Mountain A")
// Trek, Specialized.
.withNumber("Price", 100).withStringSet("Color", new
HashSet<String>(Arrays.asList("Red", "Black")))
.withString("ProductCategory", "Bicycle");
table.putItem(item);

item = new Item().withPrimaryKey("Id", 202).withString("Title", "21-Bike-202")


.withString("Description", "202 Description").withString("BicycleType",
"Road")
.withString("Brand", "Brand-Company A").withNumber("Price", 200)
.withStringSet("Color", new HashSet<String>(Arrays.asList("Green",
"Black")))
.withString("ProductCategory", "Bicycle");
table.putItem(item);

item = new Item().withPrimaryKey("Id", 203).withString("Title", "19-Bike-203")

Versión de API 2012-08-10


1093
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos: Java

.withString("Description", "203 Description").withString("BicycleType",


"Road")
.withString("Brand", "Brand-Company B").withNumber("Price", 300)
.withStringSet("Color", new HashSet<String>(Arrays.asList("Red", "Green",
"Black")))
.withString("ProductCategory", "Bicycle");
table.putItem(item);

item = new Item().withPrimaryKey("Id", 204).withString("Title", "18-Bike-204")


.withString("Description", "204 Description").withString("BicycleType",
"Mountain")
.withString("Brand", "Brand-Company B").withNumber("Price", 400)
.withStringSet("Color", new HashSet<String>(Arrays.asList("Red")))
.withString("ProductCategory", "Bicycle");
table.putItem(item);

item = new Item().withPrimaryKey("Id", 205).withString("Title", "20-Bike-205")


.withString("Description", "205 Description").withString("BicycleType",
"Hybrid")
.withString("Brand", "Brand-Company C").withNumber("Price", 500)
.withStringSet("Color", new HashSet<String>(Arrays.asList("Red", "Black")))
.withString("ProductCategory", "Bicycle");
table.putItem(item);

}
catch (Exception e) {
System.err.println("Failed to create item in " + tableName);
System.err.println(e.getMessage());
}

private static void loadSampleForums(String tableName) {

Table table = dynamoDB.getTable(tableName);

try {

System.out.println("Adding data to " + tableName);

Item item = new Item().withPrimaryKey("Name", "Amazon DynamoDB")


.withString("Category", "Amazon Web Services").withNumber("Threads",
2).withNumber("Messages", 4)
.withNumber("Views", 1000);
table.putItem(item);

item = new Item().withPrimaryKey("Name", "Amazon S3").withString("Category",


"Amazon Web Services")
.withNumber("Threads", 0);
table.putItem(item);

}
catch (Exception e) {
System.err.println("Failed to create item in " + tableName);
System.err.println(e.getMessage());
}
}

private static void loadSampleThreads(String tableName) {


try {
long time1 = (new Date()).getTime() - (7 * 24 * 60 * 60 * 1000); // 7
// days
// ago
long time2 = (new Date()).getTime() - (14 * 24 * 60 * 60 * 1000); // 14
// days
// ago

Versión de API 2012-08-10


1094
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos: Java

long time3 = (new Date()).getTime() - (21 * 24 * 60 * 60 * 1000); // 21


// days
// ago

Date date1 = new Date();


date1.setTime(time1);

Date date2 = new Date();


date2.setTime(time2);

Date date3 = new Date();


date3.setTime(time3);

dateFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));

Table table = dynamoDB.getTable(tableName);

System.out.println("Adding data to " + tableName);

Item item = new Item().withPrimaryKey("ForumName", "Amazon DynamoDB")


.withString("Subject", "DynamoDB Thread 1").withString("Message", "DynamoDB
thread 1 message")
.withString("LastPostedBy", "User A").withString("LastPostedDateTime",
dateFormatter.format(date2))
.withNumber("Views", 0).withNumber("Replies", 0).withNumber("Answered", 0)
.withStringSet("Tags", new HashSet<String>(Arrays.asList("index",
"primarykey", "table")));
table.putItem(item);

item = new Item().withPrimaryKey("ForumName", "Amazon


DynamoDB").withString("Subject", "DynamoDB Thread 2")
.withString("Message", "DynamoDB thread 2
message").withString("LastPostedBy", "User A")
.withString("LastPostedDateTime",
dateFormatter.format(date3)).withNumber("Views", 0)
.withNumber("Replies", 0).withNumber("Answered", 0)
.withStringSet("Tags", new HashSet<String>(Arrays.asList("index",
"partitionkey", "sortkey")));
table.putItem(item);

item = new Item().withPrimaryKey("ForumName", "Amazon


S3").withString("Subject", "S3 Thread 1")
.withString("Message", "S3 Thread 3 message").withString("LastPostedBy",
"User A")
.withString("LastPostedDateTime",
dateFormatter.format(date1)).withNumber("Views", 0)
.withNumber("Replies", 0).withNumber("Answered", 0)
.withStringSet("Tags", new HashSet<String>(Arrays.asList("largeobjects",
"multipart upload")));
table.putItem(item);

}
catch (Exception e) {
System.err.println("Failed to create item in " + tableName);
System.err.println(e.getMessage());
}

private static void loadSampleReplies(String tableName) {


try {
// 1 day ago
long time0 = (new Date()).getTime() - (1 * 24 * 60 * 60 * 1000);
// 7 days ago
long time1 = (new Date()).getTime() - (7 * 24 * 60 * 60 * 1000);
// 14 days ago

Versión de API 2012-08-10


1095
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos: Java

long time2 = (new Date()).getTime() - (14 * 24 * 60 * 60 * 1000);


// 21 days ago
long time3 = (new Date()).getTime() - (21 * 24 * 60 * 60 * 1000);

Date date0 = new Date();


date0.setTime(time0);

Date date1 = new Date();


date1.setTime(time1);

Date date2 = new Date();


date2.setTime(time2);

Date date3 = new Date();


date3.setTime(time3);

dateFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));

Table table = dynamoDB.getTable(tableName);

System.out.println("Adding data to " + tableName);

// Add threads.

Item item = new Item().withPrimaryKey("Id", "Amazon DynamoDB#DynamoDB Thread


1")
.withString("ReplyDateTime", (dateFormatter.format(date3)))
.withString("Message", "DynamoDB Thread 1 Reply 1
text").withString("PostedBy", "User A");
table.putItem(item);

item = new Item().withPrimaryKey("Id", "Amazon DynamoDB#DynamoDB Thread 1")


.withString("ReplyDateTime", dateFormatter.format(date2))
.withString("Message", "DynamoDB Thread 1 Reply 2
text").withString("PostedBy", "User B");
table.putItem(item);

item = new Item().withPrimaryKey("Id", "Amazon DynamoDB#DynamoDB Thread 2")


.withString("ReplyDateTime", dateFormatter.format(date1))
.withString("Message", "DynamoDB Thread 2 Reply 1
text").withString("PostedBy", "User A");
table.putItem(item);

item = new Item().withPrimaryKey("Id", "Amazon DynamoDB#DynamoDB Thread 2")


.withString("ReplyDateTime", dateFormatter.format(date0))
.withString("Message", "DynamoDB Thread 2 Reply 2
text").withString("PostedBy", "User A");
table.putItem(item);

}
catch (Exception e) {
System.err.println("Failed to create item in " + tableName);
System.err.println(e.getMessage());

}
}

Versión de API 2012-08-10


1096
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos: .NET

Creación de ejemplos de tablas y carga de datos


mediante la.AWS SDK for .NET
En el siguiente ejemplo de código C# se crean tablas y se cargan datos en ellas. La estructura de tablas
y los datos resultantes se muestran en.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 ejecutar este código en Visual
Studio, 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.DocumentModel;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
using Amazon.SecurityToken;

namespace com.amazonaws.codesamples
{
class CreateTablesLoadData
{
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();

static void Main(string[] args)


{
try
{
//DeleteAllTables(client);
DeleteTable("ProductCatalog");
DeleteTable("Forum");
DeleteTable("Thread");
DeleteTable("Reply");

// Create tables (using the AWS SDK for .NET low-level API).
CreateTableProductCatalog();
CreateTableForum();
CreateTableThread(); // ForumTitle, Subject */
CreateTableReply();

// Load data (using the .NET SDK document API)


LoadSampleProducts();
LoadSampleForums();
LoadSampleThreads();
LoadSampleReplies();
Console.WriteLine("Sample complete!");
Console.WriteLine("Press ENTER to continue");
Console.ReadLine();
}
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }

Versión de API 2012-08-10


1097
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos: .NET

catch (Exception e) { Console.WriteLine(e.Message); }


}

private static void DeleteTable(string tableName)


{
try
{
var deleteTableResponse = client.DeleteTable(new DeleteTableRequest()
{
TableName = tableName
});
WaitTillTableDeleted(client, tableName, deleteTableResponse);
}
catch (ResourceNotFoundException)
{
// There is no such table.
}
}

private static void CreateTableProductCatalog()


{
string tableName = "ProductCatalog";

var response = client.CreateTable(new CreateTableRequest


{
TableName = tableName,
AttributeDefinitions = new List<AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = "N"
}
},
KeySchema = new List<KeySchemaElement>()
{
new KeySchemaElement
{
AttributeName = "Id",
KeyType = "HASH"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 5
}
});

WaitTillTableCreated(client, tableName, response);


}

private static void CreateTableForum()


{
string tableName = "Forum";

var response = client.CreateTable(new CreateTableRequest


{
TableName = tableName,
AttributeDefinitions = new List<AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "Name",
AttributeType = "S"
}

Versión de API 2012-08-10


1098
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos: .NET

},
KeySchema = new List<KeySchemaElement>()
{
new KeySchemaElement
{
AttributeName = "Name", // forum Title
KeyType = "HASH"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 5
}
});

WaitTillTableCreated(client, tableName, response);


}

private static void CreateTableThread()


{
string tableName = "Thread";

var response = client.CreateTable(new CreateTableRequest


{
TableName = tableName,
AttributeDefinitions = new List<AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "ForumName", // Hash attribute
AttributeType = "S"
},
new AttributeDefinition
{
AttributeName = "Subject",
AttributeType = "S"
}
},
KeySchema = new List<KeySchemaElement>()
{
new KeySchemaElement
{
AttributeName = "ForumName", // Hash attribute
KeyType = "HASH"
},
new KeySchemaElement
{
AttributeName = "Subject", // Range attribute
KeyType = "RANGE"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 5
}
});

WaitTillTableCreated(client, tableName, response);


}

private static void CreateTableReply()


{
string tableName = "Reply";
var response = client.CreateTable(new CreateTableRequest

Versión de API 2012-08-10


1099
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos: .NET

{
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",

KeySchema = new List<KeySchemaElement>() {


new KeySchemaElement() {
AttributeName = "Id", KeyType = "HASH"
},
new KeySchemaElement() {
AttributeName = "PostedBy", KeyType = "RANGE"
}
},
Projection = new Projection() {
ProjectionType = ProjectionType.KEYS_ONLY
}
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 5
}
});

WaitTillTableCreated(client, tableName, response);


}

private static void WaitTillTableCreated(AmazonDynamoDBClient client, string


tableName,
CreateTableResponse response)

Versión de API 2012-08-10


1100
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos: .NET

{
var tableDescription = response.TableDescription;

string status = tableDescription.TableStatus;

Console.WriteLine(tableName + " - " + status);

// Let us wait until table is created. Call DescribeTable.


while (status != "ACTIVE")
{
System.Threading.Thread.Sleep(5000); // Wait 5 seconds.
try
{
var res = client.DescribeTable(new DescribeTableRequest
{
TableName = tableName
});
Console.WriteLine("Table name: {0}, status: {1}", res.Table.TableName,
res.Table.TableStatus);
status = res.Table.TableStatus;
}
// Try-catch to handle potential eventual-consistency issue.
catch (ResourceNotFoundException)
{ }
}
}

private static void WaitTillTableDeleted(AmazonDynamoDBClient client, string


tableName,
DeleteTableResponse response)
{
var tableDescription = response.TableDescription;

string status = tableDescription.TableStatus;

Console.WriteLine(tableName + " - " + status);

// Let us wait until table is created. Call DescribeTable


try
{
while (status == "DELETING")
{
System.Threading.Thread.Sleep(5000); // wait 5 seconds

var res = client.DescribeTable(new DescribeTableRequest


{
TableName = tableName
});
Console.WriteLine("Table name: {0}, status: {1}", res.Table.TableName,
res.Table.TableStatus);
status = res.Table.TableStatus;
}
}
catch (ResourceNotFoundException)
{
// Table deleted.
}
}

private static void LoadSampleProducts()


{
Table productCatalogTable = Table.LoadTable(client, "ProductCatalog");
// ********** Add Books *********************
var book1 = new Document();
book1["Id"] = 101;
book1["Title"] = "Book 101 Title";

Versión de API 2012-08-10


1101
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos: .NET

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

var book2 = new Document();

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

var book3 = new Document();


book3["Id"] = 103;
book3["Title"] = "Book 103 Title";
book3["ISBN"] = "333-3333333333";
book3["Authors"] = new List<string> { "Author 1", "Author2", "Author 3" }; ;
book3["Price"] = 2000;
book3["Dimensions"] = "8.5 x 11.0 x 1.5";
book3["PageCount"] = 700;
book3["InPublication"] = false;
book3["ProductCategory"] = "Book";
productCatalogTable.PutItem(book3);

// ************ Add bikes. *******************


var bicycle1 = new Document();
bicycle1["Id"] = 201;
bicycle1["Title"] = "18-Bike 201"; // size, followed by some title.
bicycle1["Description"] = "201 description";
bicycle1["BicycleType"] = "Road";
bicycle1["Brand"] = "Brand-Company A"; // Trek, Specialized.
bicycle1["Price"] = 100;
bicycle1["Color"] = new List<string> { "Red", "Black" };
bicycle1["ProductCategory"] = "Bike";
productCatalogTable.PutItem(bicycle1);

var bicycle2 = new Document();


bicycle2["Id"] = 202;
bicycle2["Title"] = "21-Bike 202Brand-Company A";
bicycle2["Description"] = "202 description";
bicycle2["BicycleType"] = "Road";
bicycle2["Brand"] = "";
bicycle2["Price"] = 200;
bicycle2["Color"] = new List<string> { "Green", "Black" };
bicycle2["ProductCategory"] = "Bicycle";
productCatalogTable.PutItem(bicycle2);

var bicycle3 = new Document();


bicycle3["Id"] = 203;
bicycle3["Title"] = "19-Bike 203";
bicycle3["Description"] = "203 description";
bicycle3["BicycleType"] = "Road";
bicycle3["Brand"] = "Brand-Company B";
bicycle3["Price"] = 300;
bicycle3["Color"] = new List<string> { "Red", "Green", "Black" };
bicycle3["ProductCategory"] = "Bike";

Versión de API 2012-08-10


1102
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos: .NET

productCatalogTable.PutItem(bicycle3);

var bicycle4 = new Document();


bicycle4["Id"] = 204;
bicycle4["Title"] = "18-Bike 204";
bicycle4["Description"] = "204 description";
bicycle4["BicycleType"] = "Mountain";
bicycle4["Brand"] = "Brand-Company B";
bicycle4["Price"] = 400;
bicycle4["Color"] = new List<string> { "Red" };
bicycle4["ProductCategory"] = "Bike";
productCatalogTable.PutItem(bicycle4);

var bicycle5 = new Document();


bicycle5["Id"] = 205;
bicycle5["Title"] = "20-Title 205";
bicycle4["Description"] = "205 description";
bicycle5["BicycleType"] = "Hybrid";
bicycle5["Brand"] = "Brand-Company C";
bicycle5["Price"] = 500;
bicycle5["Color"] = new List<string> { "Red", "Black" };
bicycle5["ProductCategory"] = "Bike";
productCatalogTable.PutItem(bicycle5);
}

private static void LoadSampleForums()


{
Table forumTable = Table.LoadTable(client, "Forum");

var forum1 = new Document();


forum1["Name"] = "Amazon DynamoDB"; // PK
forum1["Category"] = "Amazon Web Services";
forum1["Threads"] = 2;
forum1["Messages"] = 4;
forum1["Views"] = 1000;

forumTable.PutItem(forum1);

var forum2 = new Document();


forum2["Name"] = "Amazon S3"; // PK
forum2["Category"] = "Amazon Web Services";
forum2["Threads"] = 1;

forumTable.PutItem(forum2);
}

private static void LoadSampleThreads()


{
Table threadTable = Table.LoadTable(client, "Thread");

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

Versión de API 2012-08-10


1103
Amazon DynamoDB Guía para desarrolladores
Creación de ejemplos de tablas y carga de datos: .NET

var thread2 = new Document();


thread2["ForumName"] = "Amazon DynamoDB"; // Hash attribute.
thread2["Subject"] = "DynamoDB Thread 2"; // Range attribute.
thread2["Message"] = "DynamoDB thread 2 message text";
thread2["LastPostedBy"] = "User A";
thread2["LastPostedDateTime"] = DateTime.UtcNow.Subtract(new TimeSpan(21, 0, 0,
0));
thread2["Views"] = 0;
thread2["Replies"] = 0;
thread2["Answered"] = false;
thread2["Tags"] = new List<string> { "index", "primarykey", "rangekey" };

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

private static void LoadSampleReplies()


{
Table replyTable = Table.LoadTable(client, "Reply");

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

Versión de API 2012-08-10


1104
Amazon DynamoDB Guía para desarrolladores
Aplicación de ejemplo de conAWS SDK for Python (Boto3)

thread2Reply1["ReplyDateTime"] = DateTime.UtcNow.Subtract(new TimeSpan(7, 0, 0,


0)); // Range attribute.
thread2Reply1["Message"] = "DynamoDB Thread 2 Reply 1 text";
thread2Reply1["PostedBy"] = "User A";

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

Aplicación de ejemplo de DynamoDB que utiliza


elAWS SDK for Python (Boto): Toe Tic-Tac-Toe
Temas
• Paso 1: Implementación y pruebas localmente (p. 1106)
• Paso 2: Examinar el modelo de datos y los detalles de implementación (p. 1110)
• Paso 3: Implementar en producción mediante el servicio de DynamoDB (p. 1117)
• Paso 4: Eliminación de los recursos (p. 1124)

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.

A continuación se indica cómo se juega a la aplicación Tic-Tac-Toe en la Web:

1. Inicie sesión en la página de inicio de la aplicación.


2. A continuación, invite a otro usuario a jugar una partida como su contrincante.

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.

El ejercicio completa de creación de la aplicación se describe en varios pasos:

Versión de API 2012-08-10


1105
Amazon DynamoDB Guía para desarrolladores
Paso 1: Implementación y pruebas localmente

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

Paso 1: Implementación y pruebas localmente


Temas
• 1.1: Descargue e instale los paquetes obligatorios (p. 1106)
• 1.2: Pruebe la aplicación del juego (p. 1107)

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.

1.1: Descargue e instale los paquetes obligatorios


Necesitará lo siguiente para probar localmente esta aplicación:

• Python
• Flask (un micromarco de trabajo para Python)
• AWS SDK for Python (Boto)
• DynamoDB en ejecución en su equipo
• Git

Para obtener estas herramientas, haga lo siguiente:

1. Instalación de Python. Para ver instrucciones paso a paso, consulte Download Python.

La aplicación Tic-Tac-Toe se ha probado con Python versión 2.7.


2. Utilice Flask yAWS SDK for Python (Boto)con Python Package Installer (PIP):
• Instale PIP.

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

En Linux, no se especifica la extensión .exe. Solo se especifica python get-pip.py.

Versión de API 2012-08-10


1106
Amazon DynamoDB Guía para desarrolladores
Paso 1: Implementación y pruebas localmente

• Utilice PIP para instalar los paquetes Flask y Boto mediante el siguiente código.

pip install Flask


pip install boto
pip install configparser

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.

git clone https://github.com/awslabs/dynamodb-tictactoe-example-app.git

1.2: Pruebe la aplicación del juego


Para probar la aplicación Tic-Tac-Toe, debe ejecutar DynamoDB localmente en su equipo.

Para ejecutar la aplicación Tic-Tac-Toe

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.

python.exe application.py --mode local --serverPort 5000 --port 8000

En Linux, no se especifica la extensión .exe.


3. Abra el navegador web y escriba lo siguiente.

http://localhost:5000/

En el navegador aparece la página de inicio.

4. Escriba user1 en el cuadro Log in (Iniciar sesión) para iniciar sesión como user1.
Note

En este ejemplo de aplicación no se lleva a cabo la autenticación del usuario. El identificador


de usuario se utiliza solamente para identificar a los jugadores. Si dos jugadores inician

Versión de API 2012-08-10


1107
Amazon DynamoDB Guía para desarrolladores
Paso 1: Implementación y pruebas localmente

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

6. Elija CREATE (CREAR) para crear la primera partida de tres en raya.


7. Escriba user2 en el cuadro Choose an Opponent (Elegir un contrincante) y elija Create Game! (Crear
partida)

Se crea la partida agregando un elemento en la tabla Games. El estado de la partida se establece en


PENDING.
8. Abra otra ventana del navegador y escriba lo siguiente.

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á una página con una invitación pendiente de user1.

Versión de API 2012-08-10


1108
Amazon DynamoDB Guía para desarrolladores
Paso 1: Implementación y pruebas localmente

10. Elija accept (aceptar) para aceptar la invitación.

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.

Versión de API 2012-08-10


1109
Amazon DynamoDB Guía para desarrolladores
Paso 2: Examinar el modelo de datos
y los detalles de implementación

Paso 2: Examinar el modelo de datos y los detalles de


implementación
Temas
• 2.1: Modelo de datos básico (p. 1110)
• 2.2: Aplicación en acción (guía del código) (p. 1112)

2.1: Modelo de datos básico


En este ejemplo de aplicación se resaltan los siguientes conceptos del modelo de datos de DynamoDB

• 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:

Versión de API 2012-08-10


1110
Amazon DynamoDB Guía para desarrolladores
Paso 2: Examinar el modelo de datos
y los detalles de implementación

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.

• Atributos de valor concatenados— ElStatusDateatributo ilustra un valor de atributo concatenado. En


este enfoque, en lugar de crear atributos separados para almacenar el estado de la partida (PENDING,
IN_PROGRESS y FINISHED) y la fecha (cuándo se realizó la última jugada), se combinan como un solo
atributo; por ejemplo IN_PROGRESS_2014-04-30 10:20:32.

A continuación, la aplicación utiliza el atributo StatusDate para crear índices secundarios


especificando StatusDate como clave de ordenación del índice. El beneficio de utilizar el atributo de
valores concatenados StatusDate se ilustra mejor en la explicación sobre índices que encontrará más
adelante.
• Índices secundarios globales— Puede utilizar la clave principal de la tabla,GameIdPara consultar de
forma eficiente la tabla para encontrar un elemento de partida. Para consultar la tabla para hallar otros
atributos distintos de los de clave principal, DynamoDB admite la creación de índices secundarios. En
este ejemplo de aplicación, se crean los dos índices secundarios siguientes:

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

Versión de API 2012-08-10


1111
Amazon DynamoDB Guía para desarrolladores
Paso 2: Examinar el modelo de datos
y los detalles de implementación

• OpponentId-StatusDate-index. Este índice tiene OpponentId como clave de partición y StatusDate


como clave de ordenación. Puede utilizar este índice para realizar una consulta sobre Opponent, por
ejemplo, para encontrar las partidas en las que un usuario determinado ha sido el contrincante.

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

2.2: Aplicación en acción (guía del código)


Esta aplicación tiene dos páginas principales:

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

La página de inicio no se actualiza automáticamente; debe actualizarla para renovar la información de


las listas.
• Página de la partida: muestra la cuadrícula de tres en raya en la que juegan los usuarios.

La aplicación actualiza la página de la partida automáticamente cada segundo. El código JavaScript


del navegador llama al servidor web Python cada segundo para consultar la tabla Games y saber si los
elementos de partidas contenidos en la tabla han cambiado. En caso afirmativo, JavaScript activa una
actualización de la página para que el usuario vea el tablero con la información más reciente.

Vamos a estudiar en detalle el funcionamiento de la aplicación.

Página de inicio
Cuando el usuario inicia sesión, la aplicación muestra las tres listas de información siguientes.

Versión de API 2012-08-10


1112
Amazon DynamoDB Guía para desarrolladores
Paso 2: Examinar el modelo de datos
y los detalles de implementación

• 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

Versión de API 2012-08-10


1113
Amazon DynamoDB Guía para desarrolladores
Paso 2: Examinar el modelo de datos
y los detalles de implementación

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.

Uso de getGameInvites para obtener la lista de invitaciones pendientes para jugar

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.

La función especifica la consulta de la siguiente manera:

• 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_".

El índice OpponentId-StatusDate-index se utiliza para recuperar partidas a las que se ha invitado


a jugar al usuario que ha iniciado sesión; es decir, en las que el usuario que ha iniciado sesión es el
contrincante.
• La consulta limita el resultado a diez elementos.

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.

Uso de getGamesWithStatus para obtener la lista de partidas con un estado determinado

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.

inProgressGames = controller.getGamesWithStatus(session["username"], "IN_PROGRESS")


finishedGames = controller.getGamesWithStatus(session["username"], "FINISHED")

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:

Versión de API 2012-08-10


1114
Amazon DynamoDB Guía para desarrolladores
Paso 2: Examinar el modelo de datos
y los detalles de implementación

• Las partidas en curso organizadas por el usuario


• Las partidas en curso en las que el usuario es el contrincante

La función getGamesWithStatus ejecuta las dos consultas siguientes, utilizando en cada caso el índice
secundario apropiado.

• La función consulta la tabla Games mediante el índice HostId-StatusDate-index. Para el índice,


la consulta especifica los valores de clave principal; es decir, los valores tanto de la clave de partición
(HostId) como de la clave de ordenación (StatusDate), así como los operadores de comparación.

hostGamesInProgress = self.cm.getGamesTable ().query(HostId__eq=user,


StatusDate__beginswith=status,
index="HostId-StatusDate-index",
limit=10)

Fíjese en la sintaxis de Python para los operadores de comparación:


• HostId__eq=user especifica el operador de comparación de igualdad.
• StatusDate__beginswith=status especifica el operador de comparación BEGINS_WITH.
• La función consulta la tabla Games mediante el índice OpponentId-StatusDate-index.

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:

Versión de API 2012-08-10


1115
Amazon DynamoDB Guía para desarrolladores
Paso 2: Examinar el modelo de datos
y los detalles de implementación

La aplicación muestra la página de la partida en las siguientes situaciones:

• Cuando el usuario ha creado una partida e invitado a otro usuario a jugar.

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:

• Agrega un nuevo atributo específico de la jugada.


• Actualiza el valor del atributo Turn con el valor del usuario al que le toca jugar a continuación.

controller.updateBoardAndTurn(item, value, session["username"])

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.

Versión de API 2012-08-10


1116
Amazon DynamoDB Guía para desarrolladores
Paso 3: Implementación en producción

Para la llamada a update_item, el código identifica lo siguiente:

• Clave principal de la tabla Games (es decir, ItemId).

key = { "GameId" : { "S" : gameId } }

• 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 }
}
}

• Condiciones que deben cumplirse para que la actualización se lleve a cabo:


• La partida debe estar en curso. Es decir, el valor del atributo StatusDate debe comenzar por
IN_PROGRESS.
• El turno actual debe ser válido para el usuario según lo especificado por el atributo Turn.
• La casilla elegida por el usuario debe estar disponible. Es decir, el atributo correspondiente a la casilla
no debe existir.

expectations = {"StatusDate" : {"AttributeValueList": [{"S" : "IN_PROGRESS_"}],


"ComparisonOperator": "BEGINS_WITH"},
"Turn" : {"Value" : {"S" : current_player}},
position : {"Exists" : False}}

Ahora, la función llama a update_item para actualizar el elemento.

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.

Paso 3: Implementar en producción mediante el


servicio de DynamoDB
Temas
• 3.1: Creación de un rol de IAM para Amazon EC2 (p. 1119)
• 3.2: Creación de una tabla de juegos en Amazon DynamoDB (p. 1119)
• 3.3: Empaquetar e implementar el código de la aplicación Tic-Tac-Toe (p. 1119)
• 3.4: Configuración del entorno de AWS Elastic Beanstalk (p. 1121)
Versión de API 2012-08-10
1117
Amazon DynamoDB Guía para desarrolladores
Paso 3: Implementación en producción

En las secciones anteriores, hemos implementado y probado la aplicación Tic-Tac-Toe localmente en


el equipo utilizando DynamoDB Local. Ahora, vamos a implementarla en un entorno de producción, del
siguiente modo:

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

Resumiendo, debe hacer lo siguiente para implementar la aplicación Tic-Tac-Toe en un entorno de


producción:

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.

En el archivo de configuración (beanstalk.config), usted proporcionaAWSInformación de región


y punto final. La aplicación Tic-Tac-Toe utiliza esta información para determinar con qué región de
DynamoDB debe comunicarse.
3. Configure el entorno de Elastic Beanstalk. Elastic Beanstalk lanza una o varias instancias de Amazon
EC2 e implementa el paquete de la aplicación Tic-Tac-Toe en ellas. Una vez que el entorno de Elastic
Beanstalk esté preparado, deberá indicar el nombre del archivo de configuración agregando la variable
de entorno CONFIG_FILE.

Versión de API 2012-08-10


1118
Amazon DynamoDB Guía para desarrolladores
Paso 3: Implementación en producción

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.

3.1: Creación de un rol de IAM para Amazon EC2


Creación de un rol de IAM delAmazon EC2permite que la instancia Amazon EC2 en la que se ejecuta
la aplicación Tic-Tac-Toe asuma el rol correcto y realice solicitudes a la aplicación para obtener acceso
alGamesTabla INTO. Al crear el rol, elija la opción Custom Policy (Política personalizada) y copie y pegue
la siguiente política.

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

3.2: Creación de una tabla de juegos en Amazon DynamoDB


LaGamesTabla de DynamoDB almacena datos del juego. Si la tabla no existiera, la aplicación la crearía
automáticamente. En este caso, permita que la aplicación cree la tabla Games.

3.3: Empaquetar e implementar el código de la aplicación Tic-


Tac-Toe
Si ha seguido los pasos de este ejemplo, ya tendrá la aplicación Tic-Tac-Toe descargada. Si no es así,
descargue la aplicación y extraiga todos los archivos en una carpeta en su equipo local. Para obtener
instrucciones, consulte Paso 1: Implementación y pruebas localmente (p. 1106).

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.

1. Cambie a la carpeta en la que ha descargado la aplicación Tic-Tac-Toe.

Versión de API 2012-08-10


1119
Amazon DynamoDB Guía para desarrolladores
Paso 3: Implementación en producción

2. En la carpeta raíz de la aplicación, cree un archivo de texto denominado beanstalk.config con el


contenido siguiente.

[dynamodb]
region=<AWS region>
endpoint=<DynamoDB endpoint>

Por ejemplo, podría utilizar el contenido siguiente.

[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

La región especificada en el archivo de configuración es la ubicación donde la aplicación


Tic-Tac-Toe creará la propiedadGamesen DynamoDB. Debe crear la aplicación de Elastic
Beanstalk que se describe en la siguiente sección en la misma región.
Note

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

En la comunicación cliente-servidor en la cual el servidor envía la respuesta, por motivos


de seguridad el servidor envía una cookie firmada que el cliente devuelve al servidor en la
siguiente solicitud. Cuando hay un único servidor, este puede generar localmente una clave
de cifrado al iniciarse. Si hay muchos servidores, todos ellos deben conocer la misma clave
de cifrado; de lo contrario, no podrán leer las cookies establecidas por los demás servidores.
Si se agrega secret_key al archivo de configuración, indica a todos los servidores que
utilicen esta clave de cifrado.
3. Comprima el contenido de la carpeta raíz de la aplicación (que incluye el archivo
beanstalk.config); por ejemplo, TicTacToe.zip.
4. Cargue la.zipUn archivo en un bucket de Amazon Simple Storage Service (Amazon S3). En la
siguiente sección, proporcionaremos este archivo .zip a Elastic Beanstalk para cargarlo en el o los
servidores.

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.

Versión de API 2012-08-10


1120
Amazon DynamoDB Guía para desarrolladores
Paso 3: Implementación en producción

3.4: Configuración del entorno de AWS Elastic Beanstalk


En este paso, se crea una aplicación de Elastic Beanstalk, que es una colección de componentes,
incluidos los entornos. En este ejemplo, vamos a lanzar una instancia de Amazon EC2 para implementar y
ejecutar la aplicación Tic-Tac-Toe.

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:

• Debe proporcionar unaAWSNombre de región (el mismo que ha facilitado en el archivo de


configuración), un bucket de Amazon S3 y el nombre de objeto.
• Para las pruebas, la URL solicita el tipo de entorno SingleInstance y t1.micro como tipo de
instancia.
• El nombre de la aplicación debe ser único. Así pues, en la URL anterior, sugerimos que anteponga
su propio nombre a applicationName.

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.

Versión de API 2012-08-10


1121
Amazon DynamoDB Guía para desarrolladores
Paso 3: Implementación en producción

b. Al final de la sección Environment Properties (Propiedades de entorno), escriba CONFIG_FILE y


su valor beanstalk.config; a continuación, elija Save (Guardar).

Puede que la actualización del entorno tarde unos minutos en completarse.

Una vez completada la actualización, ya puede jugar.


5. En el navegador, escriba la URL que copió en el paso anterior, tal y como se muestra en el siguiente
ejemplo.

http://<pen-name>.elasticbeanstalk.com

Versión de API 2012-08-10


1122
Amazon DynamoDB Guía para desarrolladores
Paso 3: Implementación en producción

Se abrirá la página de inicio de la aplicación.

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

8. Abra otra ventana del navegador.

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

10. Inicie sesión como testuser2.


11. Vaya a la invitación de testuser1 en la lista de invitaciones pendientes y elija accept (aceptar).

Versión de API 2012-08-10


1123
Amazon DynamoDB Guía para desarrolladores
Paso 4: Eliminación de los recursos

12. Ahora aparece la página de la partida.

Pueden jugar la partida los usuarios testuser1 y testuser2. La aplicación guardará cada jugada en el
elemento correspondiente de la tabla Games.

Paso 4: Eliminación de los recursos


Se han completado la implementación y las pruebas de la aplicación Tic-Tac-Toe. La aplicación abarca
el desarrollo integral de aplicaciones web en Amazon DynamoDB, salvo la autenticación de usuarios.
La aplicación utiliza la información de inicio de sesión de la página de inicio únicamente para agregar el
nombre de un jugador al crear una partida. En una aplicación de producción, tendría que agregar el código
necesario para llevar a cabo el inicio de sesión y la autenticación de los usuarios.

Versión de API 2012-08-10


1124
Amazon DynamoDB Guía para desarrolladores
Integración con AWS Data Pipeline

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.

Para eliminar los recursos que ha creado

1. Elimine la aplicaciónGamesTabla de creación en DynamoDB.


2. Termine el entorno de Elastic Beanstalk para liberar las instancias de Amazon EC2.
3. Elimine el rol de IAM creado.
4. Elimine el objeto que ha creado en Amazon S3.

Importación y exportación de datos de DynamoDB


medianteAWS Data Pipeline
Puede usarAWS Data PipelinePara exportar datos de una tabla de DynamoDB a un archivo de un bucket
de Amazon S3. También puede utilizar la consola para importar datos de Amazon S3 a una tabla de
DynamoDB, en la mismaAWSregión o en una región diferente.
Note

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

En el siguiente diagrama se muestra información general sobre la exportación e importación de datos de


DynamoDB medianteAWS Data Pipeline.

Versión de API 2012-08-10


1125
Amazon DynamoDB Guía para desarrolladores
Integración con AWS Data Pipeline

Versión de API 2012-08-10


1126
Amazon DynamoDB Guía para desarrolladores
Requisitos previos para exportar e importar datos

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

Al exportar o importar datos de DynamoDB, se devengan costos adicionales por elAWSservicios


que se utilizan:

• AWS Data Pipeline: administra automáticamente el flujo de trabajo de importación/exportación.


• Amazon S3: contiene los datos que se exportan desde DynamoDB o se importan a DynamoDB.
• Amazon EMR: ejecuta un clúster administrado de Hadoop para realizar lecturas y escrituras
entre DynamoDB y Amazon S3. La configuración del clúster es unam3.xlargenodo de directriz
de instancia y unm3.xlargenodo principal de instancia de.

Para obtener más información, consulteAWS Data PipelinePrecios,Precios de Amazon EMR,


yPrecios de Amazon S3.

Requisitos previos para exportar e importar datos


Cuando se utiliza AWS Data Pipeline para importar y exportar datos, se deben especificar las acciones que
la canalización podrá realizar y los recursos que podrá consumir. Las acciones y los recursos permitidos se
definen medianteAWS Identity and Access Management(IAM).

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.

Creación de roles de IAM paraAWS Data Pipeline


Para usarAWS Data Pipeline, los roles de IAM de siguientes deben estar presentes en suAWSCuenta de:

• DataPipelineDefaultRole: las acciones que la canalización puede llevar a cabo automáticamente.


• DataPipelineDefaultResourceRole— elAWSLos recursos que la canalización provisionará en su nombre.
Para importar y exportar datos de DynamoDB, estos recursos incluyen un clúster de Amazon EMR y las
instancias de Amazon EC2 asociadas a él.

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

Versión de API 2012-08-10


1127
Amazon DynamoDB Guía para desarrolladores
Requisitos previos para exportar e importar datos

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

1. Inicie sesión en la AWS Management Console y abra la consola de IAM en https://


console.aws.amazon.com/iam/.
2. En el panel de la consola de IAM, haga clic enRoles de.
3. Haga clic en Create Role (Crear rol) y realice las siguientes operaciones:

a. En el navegadorAWSService (Servicio)Entidad de confianza, elijaData Pipeline.


b. En el panel Select your use case (Seleccione su caso de uso), elija Data Pipeline (Canalización
de datos) y, a continuación, elija Next:Permissions (Siguiente:Permisos).
c. Observe que la política AWSDataPipelineRole se asocia automáticamente. Elija Next: Review.
d. En el campo Role name (Nombre de rol), escriba DataPipelineDefaultRole como nombre
del rol y elija Create role (Crear rol).
4. Haga clic en Create Role (Crear rol) y realice las siguientes operaciones:

a. En el navegadorAWSService (Servicio)Entidad de confianza, elijaData Pipeline.


b. En el panel Select your use case (Seleccione su caso de uso), elija EC2 Role for Data
Pipeline (Rol de EC2 para canalización de datos) y, a continuación, elija Next:Permissions
(Siguiente:Permisos).
c. Observe que la política AmazonEC2RoleForDataPipelineRole se asocia automáticamente.
Elija Next: Review.
d. En el campo Role name (Nombre de rol), escriba DataPipelineDefaultResourceRole como
nombre del rol y elija Create role (Crear rol).

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

Concesión de permisos a los usuarios y grupos de IAM para


realizar tareas de exportación e importación
Si desea permitir que otros usuarios, roles o grupos de IAM importen y exporten los datos de sus tablas
de DynamoDB, puede crear una política de IAM y adjuntársela a los usuarios o grupos que designe. La
política contiene únicamente los permisos necesarios para realizar estas tareas.

Conceder acceso completo


En el siguiente procedimiento se describe cómo adjuntar elAWSPolíticas administradas
porAmazonDynamoDBFullAccess,AWSDataPipeline_FullAccessy una política en línea de Amazon
EMR a un usuario de IAM. Estas políticas administradas proporcionan acceso completo aAWS Data
Pipeliney a los recursos de DynamoDB, y utilizados con la política en línea de Amazon EMR, permiten al
usuario realizar las acciones descritas en esta documentación.
Note

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.

1. Inicie sesión en la AWS Management Console y abra la consola de IAM en https://


console.aws.amazon.com/iam/.

Versión de API 2012-08-10


1128
Amazon DynamoDB Guía para desarrolladores
Requisitos previos para exportar e importar datos

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

10. Haga clic enReview policy.


11. TipoEMRforDynamoDBDataPipelineen el campo de nombre.
12. Haga clic enCrear política.

Note

Puede utilizar un procedimiento similar para adjuntar esta política administrada a un rol o grupo,
en lugar de a un usuario.

Restricción del acceso a determinadas tablas de DynamoDB


Si desea restringir el acceso de forma que un usuario solo pueda exportar o importar un subconjunto de
las tablas, tendrá que crear un documento de política de IAM personalizado. Puede utilizar el proceso
descrito enConceder acceso completo (p. 1128)Como punto de partida para la política personalizada y, a
continuación, modificarla para permitir que un usuario solo pueda trabajar con las tablas que especifique.

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.

1. Inicie sesión en la AWS Management Console y abra la consola de IAM en https://


console.aws.amazon.com/iam/.
2. En el panel de la consola de IAM, haga clic enPolíticasy haga clic en.Creación de política de.

Versión de API 2012-08-10


1129
Amazon DynamoDB Guía para desarrolladores
Requisitos previos para exportar e importar datos

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"
},

...remainder of document omitted...

Para restringir la política, primero debe eliminar la siguiente línea:

"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"
]
},

Versión de API 2012-08-10


1130
Amazon DynamoDB Guía para desarrolladores
Requisitos previos para exportar e importar datos

Note

Reemplazarus-west-2con la región en la que residen sus tablas de DynamoDB.


Sustituya 123456789012 por su nombre de cuenta de AWS.

Por último, agregue la nueva instrucción Action al documento de política:

{
"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"
},

...remainder of document omitted...

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.

Versión de API 2012-08-10


1131
Amazon DynamoDB Guía para desarrolladores
Exportación de datos de DynamoDB a Amazon S3

Exportación de datos de DynamoDB a Amazon S3


En esta sección se describe cómo exportar los datos de una o varias tablas de DynamoDB a un bucket de
Amazon S3. Debe crear previamente el bucket de Amazon S3 para poder realizar la exportación.
Important

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

1. Inicie sesión en el iconoAWS Management Consoley abra el iconoAWS Data Pipelineconsola de


enhttps://console.aws.amazon.com/datapipeline/.
2. Si no tiene ninguna canalización en laAWSregión de, elijaComenzar ahora.

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:

a. En el campo Name (Nombre), escriba el nombre de la canalización. Por ejemplo:


MyDynamoDBExportPipeline.
b. Para el parámetro Source (Origen), seleccione Build using a template (Construir utilizando una
plantilla). En la lista desplegable de plantillas, seleccione Export DynamoDB table to S3 (Exportar
tabla de DynamoDB a S3).
c. En el navegadorNombre de la tabla de DynamoDB, escriba el nombre de la tabla de DynamoDB
que desee exportar.
d. En el navegadorOutput S3 folderEn el cuadro de texto, escriba el URI de Amazon S3 en el que se
escribirá el archivo de exportación. Por ejemplo: s3://mybucket/exports

El formato de este URI es s3://bucketname/folder, donde:

• bucketnamees el nombre del bucket de Amazon S3.


• folder es el nombre de una carpeta de ese bucket. Si la carpeta no existe, se creará
automáticamente. Si no especifica el nombre de la carpeta, se le asignará un nombre con este
formato: s3://bucketname/region/tablename.
e. En el navegadorUbicación de S3 para registrosEn el que se escribirá el archivo log de la
exportación, escriba el URI de Amazon S3. Por ejemplo: s3://mybucket/logs/

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.

Versión de API 2012-08-10


1132
Amazon DynamoDB Guía para desarrolladores
Importación de datos de Amazon S3 a DynamoDB

Importación de datos de Amazon S3 a DynamoDB


En esta sección se da por hecho que ya ha exportado datos de una tabla de DynamoDB y que el archivo
de exportación se ha escrito en el bucket de Amazon S3. El formato interno de este archivo se describe
enVerificar archivo de exportación de datosen laAWS Data PipelineGuía para desarrolladores. Tenga en
cuenta que este es elSoloformato de archivo que DynamoDB puede importar conAWS Data Pipeline.

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 ya exista, porque el proceso de importación no creará la tabla.


• La tabla de destino tenga el mismo esquema de claves que la tabla de origen.

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.

1. Inicie sesión en el iconoAWS Management Consoley abra el iconoAWS Data Pipelineconsola de


enhttps://console.aws.amazon.com/datapipeline/.
2. (Opcional) Si desea realizar una importación entre regiones, vaya a la esquina superior derecha de la
ventana y elija la región de destino.
3. Elija Create new pipeline (Crear nueva canalización).
4. En la página Create Pipeline (Crear canalización), proceda del modo siguiente:

a. En el campo Name (Nombre), escriba el nombre de la canalización. Por ejemplo:


MyDynamoDBImportPipeline.
b. Para el parámetro Source (Origen), seleccione Build using a template (Construir utilizando una
plantilla). En la lista desplegable de plantillas, seleccione Import DynamoDB backup data from S3
(Importar datos de copia de seguridad de DynamoDB desde S3).
c. En el navegadorInput S3 folderEn el cuadro de texto, escriba el URI de Amazon S3 en el que se
encuentre el archivo de exportación. Por ejemplo: s3://mybucket/exports

El formato de este URI es s3://bucketname/folder, donde:

• bucketnamees el nombre del bucket de Amazon S3.


• folder es el nombre de la carpeta que contiene el archivo de exportación.

El trabajo de importación esperará encontrar un archivo en la ubicación de Amazon S3


especificada. El formato interno del archivo se describe enVerificar archivo de exportación de
datosen laAWS Data PipelineGuía para desarrolladores.

Versión de API 2012-08-10


1133
Amazon DynamoDB Guía para desarrolladores
Troubleshooting

d. En el navegadorNombre de tabla de DynamoDB destinoEn el campo de, escriba el nombre de la


tabla de DynamoDB a la que desee importar los datos.
e. En el navegadorUbicación de S3 para registrosEn el que se escribirá el archivo log de la
importación, escriba el URI de Amazon S3. Por ejemplo: s3://mybucket/logs/

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.

Versión de API 2012-08-10


1134
Amazon DynamoDB Guía para desarrolladores
Plantillas predefinidas paraAWS Data Pipeliney DynamoDB

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.

Plantillas predefinidas paraAWS Data Pipeliney


DynamoDB
Si desea comprender mejor el modo en queAWS Data PipelinePor último, recomendamos consultar
laAWS Data PipelineGuía para desarrolladores. Esta guía contiene tutoriales paso a paso para crear
canalizaciones y trabajar con ellas. Puede utilizar estos tutoriales como punto de partida para crear sus
propias canalizaciones. Recomendamos leer el tutorial de AWS Data Pipeline, que recorre uno a uno los
pasos necesarios para crear una canalización de exportación e importación que puede personalizar de
acuerdo con sus requisitos. ConsulteTutorial: Importar y exportar a Amazon DynamoDB medianteAWS
Data Pipelineen laAWS Data PipelineGuía para desarrolladores.

AWS Data Pipelineofrece varias plantillas para crear canalizaciones; las siguientes son pertinentes para
DynamoDB.

Exportación de datos entre DynamoDB y Amazon S3


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

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:

• Exportación de DynamoDB a Amazon S3


• Exportación de Amazon S3 a DynamoDB

Amazon DynamoDB Storage Backend for Titan


El proyecto DynamoDB Storage Backend for Titan se ha reemplazado por Amazon DynamoDB Storage
Backend para JanusGraph, disponible enGitHub.

Para obtener instrucciones actualizadas sobre DynamoDB Storage Backend para JanusGraph,
consulteREADME.mdfile.

Palabras reservadas en DynamoDB


Las siguientes palabras clave están reservadas para el uso de DynamoDB. No utilice ninguna de estas
palabras como nombres de atributos en las expresiones. Esta lista no distingue entre mayúsculas y minús

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

Versión de API 2012-08-10


1135
Amazon DynamoDB Guía para desarrolladores
Palabras reservadas en DynamoDB

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

Versión de API 2012-08-10


1136
Amazon DynamoDB Guía para desarrolladores
Palabras reservadas en DynamoDB

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

Versión de API 2012-08-10


1137
Amazon DynamoDB Guía para desarrolladores
Palabras reservadas en DynamoDB

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

Versión de API 2012-08-10


1138
Amazon DynamoDB Guía para desarrolladores
Palabras reservadas en DynamoDB

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

Versión de API 2012-08-10


1139
Amazon DynamoDB Guía para desarrolladores
Palabras reservadas en DynamoDB

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

Versión de API 2012-08-10


1140
Amazon DynamoDB Guía para desarrolladores
Palabras reservadas en DynamoDB

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

Versión de API 2012-08-10


1141
Amazon DynamoDB Guía para desarrolladores
Palabras reservadas en DynamoDB

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

Versión de API 2012-08-10


1142
Amazon DynamoDB Guía para desarrolladores
Palabras reservadas en DynamoDB

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

Versión de API 2012-08-10


1143
Amazon DynamoDB Guía para desarrolladores
Parámetros condicionales heredados

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

Parámetros condicionales heredados


En esta sección se comparan los parámetros condicionales heredados con los parámetros de expresión de
DynamoDB.

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

DynamoDB no permite mezclar parámetros condicionales heredados con parámetros


de expresión en una misma llamada. Por ejemplo, llamar a la operación Query con
AttributesToGet y ConditionExpression dará lugar a un error.

Versión de API 2012-08-10


1144
Amazon DynamoDB Guía para desarrolladores
AttributesToGet

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.

Si utiliza este API... Con estos parámetros Utilice estos parámetros de


heredados... expresión en su lugar

BatchGetItem AttributesToGet ProjectionExpression

DeleteItem Expected ConditionExpression

GetItem AttributesToGet ProjectionExpression

PutItem Expected ConditionExpression

Query AttributesToGet ProjectionExpression

KeyConditions KeyConditionExpression

QueryFilter FilterExpression

Scan AttributesToGet ProjectionExpression

ScanFilter FilterExpression

UpdateItem AttributeUpdates UpdateExpression

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.

Tenga en cuenta queAttributesToGetno modifica el consumo de desempeño provisionado. DynamoDB


determina las 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.

Versión de API 2012-08-10


1145
Amazon DynamoDB Guía para desarrolladores
AttributeUpdates

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:

aws dynamodb get-item \


--table-name Music \
--attributes-to-get '["Artist", "Genre"]' \
--key '{
"Artist": {"S":"No One You Know"},
"SongTitle": {"S":"Call Me Today"}
}'

Pero, en su lugar, podría usar una expresión ProjectionExpression:

aws dynamodb get-item \


--table-name Music \
--projection-expression "Artist, Genre" \
--key '{
"Artist": {"S":"No One You Know"},
"SongTitle": {"S":"Call Me Today"}
}'

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:

• Value: el nuevo valor, si procede, de este atributo.


• Action: un valor que especifica cómo llevar a cabo la actualización. Esta acción solo es válida para un
atributo existente cuyo tipo de datos sea Number o que sea un conjunto; no use ADD con otros tipos de
datos.

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:

Versión de API 2012-08-10


1146
Amazon DynamoDB Guía para desarrolladores
AttributeUpdates

• Si el atributo existente es un número, y siValuees también un número, entoncesValueSe agrega


matemáticamente al atributo existente. Si Value es un número negativo, entonces se resta del
atributo existente.
Note

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:

aws dynamodb update-item \


--table-name Music \
--key '{
"SongTitle": {"S":"Call Me Today"},
"Artist": {"S":"No One You Know"}
}' \
--attribute-updates '{
"Genre": {
"Action": "PUT",
"Value": {"S":"Rock"}
}
}'

Pero, en su lugar, podría usar una expresión UpdateExpression:

aws dynamodb update-item \

Versión de API 2012-08-10


1147
Amazon DynamoDB Guía para desarrolladores
ConditionalOperator

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

Si se omite ConditionalOperator, entonces AND es el valor predeterminado.

La operación se llevará a cabo correctamente solo si todo el mapa se evalúa en true.


Note

Este parámetro no es compatible con atributos de tipo List o Map.

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.

Si el mapa Expected se evalúa en true, entonces la operación condicional se realiza correctamente; de lo


contrario, se produce un error.

Expected contiene lo siguiente:

• AttributeValueList: uno o más valores que se evaluarán respecto al atributo suministrado. El


número de valores de la lista depende del valor de ComparisonOperator que se utilice.

Para el tipo Number, las comparaciones de los valores son numéricas.

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.

Están disponibles los siguientes operadores de comparación:

EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS |


BEGINS_WITH | IN | BETWEEN

Versión de API 2012-08-10


1148
Amazon DynamoDB Guía para desarrolladores
Expected

A continuación se indican las descripciones de cada operador de comparación.


• EQ: igual que.EQse admite para todos los tipos de datos, incluidas las listas y los mapas.

AttributeValueListSolo puede contener unaAttributeValueelemento de tipo String, Number,


Binary, Binary, Binary, Binary, Binary Set. Si un elemento contiene unAttributeValueelemento de
un tipo distinto del proporcionado 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"]}.
• NE: distinto de.NEse admite para todos los tipos de datos, incluidas las listas y los mapas.

AttributeValueListSolo puede contener unaAttributeValuede tipo String, Number, Binary,


Binary, Binary, Binary, Binary Set. Si un elemento contiene unAttributeValueDe un tipo distinto
del proporcionado 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"]}.
• LE: menor o igual que.

AttributeValueListSolo puede contener unaAttributeValueelemento de tipo String, Number


o Binary (no de tipo Set). Si un elemento contiene unAttributeValueelemento de un tipo distinto
del proporcionado 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.

AttributeValueListSolo puede contener unaAttributeValuede tipo String, Number o Binary


(no de tipo Set). Si un elemento contiene unAttributeValueelemento de un tipo distinto del
proporcionado 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"]}.
• GE: mayor o igual que.

AttributeValueListSolo puede contener unaAttributeValueelemento de tipo String, Number


o Binary (no de tipo Set). Si un elemento contiene unAttributeValueelemento de un tipo distinto
del proporcionado 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.

AttributeValueListSolo puede contener unaAttributeValueelemento de tipo String, Number


o Binary (no de tipo Set). Si un elemento contiene unAttributeValueelemento de un tipo distinto
del proporcionado 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"]}.
• NOT_NULL: el atributo existe.NOT_NULLse admite para todos los tipos de datos, incluidas las listas y
los mapas.
Note

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

Este operador comprueba si no existe un atributo, no su tipo de datos. Si el tipo de datos


del atributo»a«es nulo, y lo evalúas usandoNULL, el resultado es un booleanofalse. Esto
se debe a que el atributo "a" existe; su tipo de datos no es pertinente para el operador de
comparación NULL.
• CONTAINS: comprueba si hay Versión de API 2012-08-10
una subsecuencia, o un valor en un conjunto.
1149
Amazon DynamoDB Guía para desarrolladores
Expected

AttributeValueListSolo puede contener unaAttributeValueelemento de tipo String, Number


o Binary (no de tipo Set). 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 ("SS", "NS" o "BS"), entonces el operador se
evalúa en true si encuentra una coincidencia exacta con cualquier miembro del conjunto.

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.

AttributeValueListSolo puede contener unaAttributeValueelemento de tipo String, Number


o Binary (no de tipo Set). 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 ("SS",
"NS" o "BS"), entonces el operador se evalúa en true si no (does not) encuentra una coincidencia
exacta con cualquier miembro del 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.

AttributeValueListSolo puede contener unaAttributeValuede tipo 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 Set).
• IN: comprueba si hay entradas que coincidan en dos conjuntos.

AttributeValueListPuede contener una o variasAttributeValueElementos de tipo String,


Number o Binary (no de tipo Set). Estos atributos se comparan con un atributo existente 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.
• BETWEEN: mayor o igual que el primer valor y menor o igual que el segundo valor.

AttributeValueListdebe contener dosAttributeValueElementos del mismo tipo, que puede


ser String, Number o Binary (pero no de tipo Set). 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 unAttributeValueelemento de un tipo distinto del proporcionado 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"]}.

Los parámetros siguientes se pueden utilizar en lugar de AttributeValueList y


ComparisonOperator:

• Value: valor que DynamoDB compara con un atributo.


• Exists: valor de tipo Boolean que hace que DynamoDB evalúe el valor antes de intentar la operación
condicional.
• SiExistsestrue, DynamoDB comprobará si el valor del atributo ya existe en la tabla. Si lo encuentra,
entonces la condición se evalúa en true; de lo contrario, la condición se evalúa en false.
• SiExistsesfalse, DynamoDB presupone que el valor del atributonotexisten en la tabla. Si el valor
no existe, entonces el supuesto es válido y la condición se evalúa en true. Si el valor se encuentra, a
pesar del supuesto de que no existía, la condición se evalúa en false.

Tenga en cuenta que el valor predeterminado de Exists es true.


Versión de API 2012-08-10
1150
Amazon DynamoDB Guía para desarrolladores
KeyConditions

LaValueyExistsLos parámetros son incompatibles con


lasAttributeValueListyComparisonOperator. Tenga en cuenta que si utiliza los dos conjuntos de
parámetros a la vez, DynamoDB devolverá una excepción ValidationException.
Note

Este parámetro no es compatible con atributos de tipo List o Map.

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:

aws dynamodb update-item \


--table-name Music \
--key '{
"Artist": {"S":"No One You Know"},
"SongTitle": {"S":"Call Me Today"}
}' \
--attribute-updates '{
"Price": {
"Action": "PUT",
"Value": {"N":"1.98"}
}
}' \
--expected '{
"Price": {
"ComparisonOperator": "LE",
"AttributeValueList": [ {"N":"2.00"} ]
}
}'

Pero, en su lugar, podría usar una expresión ConditionExpression:

aws dynamodb update-item \


--table-name Music \
--key '{
"Artist": {"S":"No One You Know"},
"SongTitle": {"S":"Call Me Today"}
}' \
--update-expression 'SET Price = :p1' \
--condition-expression 'Price <= :p2' \
--expression-attribute-values '{
":p1": {"N":"1.98"},
":p2": {"N":"2.00"}
}'

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.

Versión de API 2012-08-10


1151
Amazon DynamoDB Guía para desarrolladores
KeyConditions

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:

• AttributeValueList: uno o más valores que se evaluarán respecto al atributo suministrado. El


número de valores de la lista depende del valor de ComparisonOperator que se utilice.

Para el tipo Number, las comparaciones de los valores son numéricas.

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.

Para KeyConditions, solo se admiten los siguientes operadores de comparación:

EQ | LE | LT | GE | GT | BEGINS_WITH | BETWEEN

A continuación se indican las descripciones de estos operadores de comparación.


• EQ: igual que.

AttributeValueListSolo puede contener unaAttributeValuede tipo String, Number o Binary


(no de tipo Set). Si un elemento contiene unAttributeValueelemento 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"]}.
• LE: menor o igual que.

AttributeValueListSolo puede contener unaAttributeValueelemento de tipo String, Number


o Binary (no de tipo Set). Si un elemento contiene unAttributeValueelemento de un tipo distinto
del proporcionado 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.

AttributeValueListSolo puede contener unaAttributeValuede tipo String, Number o Binary


(no de tipo Set). Si un elemento contiene unAttributeValueelemento de un tipo distinto del
proporcionado 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"]}.
• GE: mayor o igual que.

AttributeValueListSolo puede contener unaAttributeValueelemento de tipo String, Number


o Binary (no de tipo Set). Si un elemento contiene unAttributeValueelemento de un tipo distinto
del proporcionado 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.

AttributeValueListSolo puede contener unaAttributeValueelemento de tipo String, Number


o Binary (no de tipo Set). Si un elemento contiene unAttributeValueelemento de un tipo distinto
del proporcionado 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.

Versión de API 2012-08-10


1152
Amazon DynamoDB Guía para desarrolladores
QueryFilter

AttributeValueListSolo puede contener unaAttributeValuede tipo 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 Set).
• BETWEEN: mayor o igual que el primer valor y menor o igual que el segundo valor.

AttributeValueListdebe contener dosAttributeValueElementos del mismo tipo, que puede


ser String, Number o Binary (pero no de tipo Set). 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 unAttributeValueelemento de un tipo distinto del proporcionado 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"]}.

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:

aws dynamodb query \


--table-name Music \
--key-conditions '{
"Artist":{
"ComparisonOperator":"EQ",
"AttributeValueList": [ {"S": "No One You Know"} ]
},
"SongTitle":{
"ComparisonOperator":"BETWEEN",
"AttributeValueList": [ {"S": "A"}, {"S": "M"} ]
}
}'

Pero, en su lugar, podría usar una expresión KeyConditionExpression:

aws dynamodb query \


--table-name Music \
--key-condition-expression 'Artist = :a AND SongTitle BETWEEN :t1 AND :t2' \
--expression-attribute-values '{
":a": {"S": "No One You Know"},
":t1": {"S": "A"},
":t2": {"S": "M"}
}'

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.

Este parámetro no es compatible con atributos de tipo List o Map.


Note

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

Versión de API 2012-08-10


1153
Amazon DynamoDB Guía para desarrolladores
QueryFilter

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:

• AttributeValueList: uno o más valores que se evaluarán respecto al atributo suministrado. El


número de valores de la lista depende del operador especificado en ComparisonOperator.

Para el tipo Number, las comparaciones de los valores son numéricas.

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.

Están disponibles los siguientes operadores de comparación:

EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS |


BEGINS_WITH | IN | BETWEEN

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:

aws dynamodb query \


--table-name Music \
--key-conditions '{
"Artist": {
"ComparisonOperator": "EQ",
"AttributeValueList": [ {"S": "No One You Know"} ]
}
}' \
--query-filter '{
"Price": {
"ComparisonOperator": "GT",
"AttributeValueList": [ {"N": "1.00"} ]
}
}'

Pero, en su lugar, podría usar una expresión FilterExpression:

aws dynamodb query \


--table-name Music \
--key-condition-expression 'Artist = :a' \
--filter-expression 'Price > :p' \
--expression-attribute-values '{
":p": {"N":"1.00"},
":a": {"S":"No One You Know"}
}'

Versión de API 2012-08-10


1154
Amazon DynamoDB Guía para desarrolladores
ScanFilter

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

Este parámetro no es compatible con atributos de tipo List o Map.

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:

• AttributeValueList: uno o más valores que se evaluarán respecto al atributo suministrado. El


número de valores de la lista depende del operador especificado en ComparisonOperator.

Para el tipo Number, las comparaciones de los valores son numéricas.

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.

Están disponibles los siguientes operadores de comparación:

EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS |


BEGINS_WITH | IN | BETWEEN

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:

aws dynamodb scan \


--table-name Music \
--scan-filter '{
"Genre":{
"AttributeValueList":[ {"S":"Rock"} ],
"ComparisonOperator": "EQ"
}
}'

Pero, en su lugar, podría usar una expresión FilterExpression:

aws dynamodb scan \


--table-name Music \
--filter-expression 'Genre = :g' \
--expression-attribute-values '{
":g": {"S":"Rock"}
}'

Versión de API 2012-08-10


1155
Amazon DynamoDB Guía para desarrolladores
Escritura de condiciones con parámetros heredados

Escritura de condiciones con parámetros heredados


En la siguiente sección se describe cómo escribir condiciones para usarlas con parámetros heredados,
tales como Expected, QueryFilter y ScanFilter.
Note

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:

• ComparisonOperator: mayor que, menor que, igual que, etc.


• AttributeValueList(opcional): valor o valores de atributo respecto a los que se va a establecer la
comparación. Según cuál esa el operador ComparisonOperator utilizado, AttributeValueList
puede contener uno, dos o más valores; o puede omitirse.

En las siguientes secciones se describen los distintos operadores de comparación, además de ejemplos
de cómo utilizarlos en las condiciones.

Operadores de comparación sin valores de atributos


• NOT_NULL: es true si un atributo existe.
• NULL: es true si un atributo no existe.

Utilice estos operadores para comprobar si un atributo existe o no. Dado que no hay ningún valor que
comparar, no especifique AttributeValueList.

Ejemplo

La siguiente expresión se evalúa en true si el atributo Dimensions existe.

...
"Dimensions": {
ComparisonOperator: "NOT_NULL"
}
...

Operadores de comparación con un valor de atributo


• EQ: es true si un atributo 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. 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.

Versión de API 2012-08-10


1156
Amazon DynamoDB Guía para desarrolladores
Escritura de condiciones con parámetros heredados

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

Las siguientes expresiones se evalúan en true si:

• El precio de un producto es mayor que 100.

...
"Price": {
ComparisonOperator: "GT",
AttributeValueList: [ {"N":"100"} ]
}
...

• La categoría de un producto comienza con "Bo".

Versión de API 2012-08-10


1157
Amazon DynamoDB Guía para desarrolladores
Escritura de condiciones con parámetros heredados

...
"ProductCategory": {
ComparisonOperator: "BEGINS_WITH",
AttributeValueList: [ {"S":"Bo"} ]
}
...

• Un producto está disponible en rojo, verde o negro:

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

Operadores de comparación con dos valores de atributos


• BETWEEN: es true si un valor está comprendido entre un límite inferior y un límite superior, ambos
incluidos.

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

Operadores de comparación conNValores de los atributos


• IN: es true si un valor es igual que cualquiera de los valores de una lista. Solo se admiten valores
escalares en la lista, no conjuntos. El atributo de destino debe ser del mismo tipo y valor exactos para
que se produzca la coincidencia.

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.

Versión de API 2012-08-10


1158
Amazon DynamoDB Guía para desarrolladores
Escritura de condiciones con parámetros heredados

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

La siguiente expresión se evalúa en true si el valor de Id es 201, 203 o 205.

...
"Id": {
ComparisonOperator: "IN",
AttributeValueList: [ {"N":"201"}, {"N":"203"}, {"N":"205"} ]
}
...

Uso de varias condiciones


DynamoDB permite combinar varias condiciones para crear expresiones complejas. Para ello, hay que
proporcionar al menos dos expresiones, con un ConditionalOperator (p. 1148) opcional.

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

Versión de API 2012-08-10


1159
Amazon DynamoDB Guía para desarrolladores
Escritura de condiciones con parámetros heredados

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.

Otros operadores condicionales


En versiones anteriores de DynamoDB, elExpectedEl parámetro se comportaba de forma distinta para las
escrituras condicionales. Cada elemento del cuadro de textoExpectedrepresentaba un nombre de atributo
que DynamoDB debía comprobar, además de lo siguiente:

• Value: valor que se va a comparar con el atributo.


• Exists: determina si el valor existe antes de intentar la operació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:

aws dynamodb delete-item \


--table-name ProductCatalog \
--key '{
"Id": {"N":"600"}
}' \
--expected '{
"InPublication": {
"Exists": true,
"Value": {"BOOL":false}
}

Versión de API 2012-08-10


1160
Amazon DynamoDB Guía para desarrolladores
Versión anterior del API de bajo nivel (2011-12-05)

}'

En el siguiente ejemplo se realiza la misma operación, pero sin la condición heredada:

aws dynamodb delete-item \


--table-name ProductCatalog \
--key '{
"Id": {"N":"600"}
}' \
--expected '{
"InPublication": {
"ComparisonOperator": "EQ",
"AttributeValueList": [ {"BOOL":false} ]
}
}'

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:

aws dynamodb put-item \


--table-name ProductCatalog \
--item '{
"Id": {"N":"500"},
"Title": {"S":"Book 500 Title"}
}' \
--expected '{
"Id": { "Exists": false }
}'

En el siguiente ejemplo se realiza la misma operación, pero sin la condición heredada:

aws dynamodb put-item \


--table-name ProductCatalog \
--item '{
"Id": {"N":"500"},
"Title": {"S":"Book 500 Title"}
}' \
--expected '{
"Id": { "ComparisonOperator": "NULL" }
}'

Note
Para las condiciones en elExpected, no utilice el archivo heredadoValueyExistsjunto con
lasComparisonOperatoryAttributeValueList. Si lo hace, se producirá un error en la
escritura condicional.

Versión anterior del API de bajo nivel (2011-12-05)


En esta sección se documentan las operaciones disponibles en la versión anterior del API de bajo nivel
de DynamoDB (2011-12-05). Esta versión del API de bajo nivel se mantiene para ofrecer compatibilidad
retroactiva con las aplicaciones existentes.

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

Versión de API 2012-08-10


1161
Amazon DynamoDB Guía para desarrolladores
BatchGetItem

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

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

Si no se puede procesar ningún elemento porque no hay desempeño provisionado


suficiente en cada una de las tablas objeto de la solicitud, DynamoDB devuelve un valor
deProvisionedThroughputExceededExceptionERROR.
Note

Por defecto,BatchGetItemrealiza lecturas consistentes finales en cada tabla incluida en la


solicitud. Si desea realizar en su lugar lecturas consistentes, puede establecer el parámetro
ConsistentRead en true para cada tabla.

Versión de API 2012-08-10


1162
Amazon DynamoDB Guía para desarrolladores
BatchGetItem

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

Nombre Descripción Obligatorio

RequestItems Contenedor del nombre Sí


de la tabla y los elementos
correspondientes que se deben
obtener según su clave principal.
Mientras se solicitan elementos,
cada nombre de tabla puede
invocarse solo una vez por
operación.

Type: Cadena

Valor predeterminado: Ninguna

Table Nombre de la tabla que Sí


contiene los elementos que
hay que obtener. La entrada es
simplemente una cadena que
especifica una tabla existente sin
ninguna etiqueta.

Type: Cadena

Versión de API 2012-08-10


1163
Amazon DynamoDB Guía para desarrolladores
BatchGetItem

Nombre Descripción Obligatorio


Valor predeterminado: Ninguna

Table:Keys Valores de clave principal que Sí


definen los elementos de la
tabla especificada. Para obtener
más información sobre claves
principales, consulte Clave
principal (p. 6).

Type: Claves

Table:AttributesToGet Matriz de nombres de No


atributos contenidos en la
tabla especificada. Si no se
especifican sus nombres, se
devuelven todos los atributos. Si
algún atributo no se encuentra,
no aparecerá en los resultados.

Type: Matriz

Table:ConsistentRead Si se establece en true, se No


emite una lectura consistente;
en caso contrario, se utiliza una
lectura consistente final.

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

Versión de API 2012-08-10


1164
Amazon DynamoDB Guía para desarrolladores
BatchGetItem

}],
"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

Responses Nombres de tablas y los atributos de los elementos


respectivos de las tablas.

Type: Map

Table Nombre de la tabla que contiene los elementos. La


entrada es simplemente una cadena que especifica
la tabla existente sin ninguna etiqueta.

Type: Cadena

Items Contenedor de los nombres y valores de los


atributos que coinciden con los parámetros de la
operación.

Type: Map, mapa de los nombres de atributos y


sus tipos de datos y valores.

ConsumedCapacityUnits Número de unidades de capacidad de lectura


consumidas para cada tabla. Este valor muestra
el número aplicado al desempeño provisionado.
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, consulteAdministración
de la configuración en tablas de capacidad
provisionadas de DynamoDB (p. 350).

Type: Número

UnprocessedKeys Contiene una matriz de tablas y sus respectivos


claves que no se han procesado en la respuesta
actual, posiblemente debido a que se ha
alcanzado un límite de tamaño de respuesta.
LaUnprocessedKeysestá en la misma forma
que unRequestItemsparámetro (por lo que se
puede proporcionar directamente a una excepción
posterior.BatchGetItemoperación). Para
obtener más información, consulte el parámetro
RequestItems anterior.

Type: Matriz

UnprocessedKeys: Table: Keys Valores de los atributos de clave principal que


definen los elementos y los atributos asociados

Versión de API 2012-08-10


1165
Amazon DynamoDB Guía para desarrolladores
BatchGetItem

Nombre Descripción
con los elementos. Para obtener más información
sobre claves principales, consulte Clave
principal (p. 6).

Type: Array; matriz de pares de nombre-valor.

UnprocessedKeys: Table: AttributesToGet Nombres de los atributos contenidos en la tabla


especificada. Si no se especifican sus nombres, se
devuelven todos los atributos. Si algún atributo no
se encuentra, no aparecerá en los resultados.

Type: Array, matriz de nombres de atributos.

UnprocessedKeys: Table: ConsistentRead Si se establece en true, se utiliza una lectura


consistente para la tabla especificada; en caso
contrario, se utiliza una lectura consistente final.

Type: Booleano.

Errores especiales

Error Descripción

ProvisionedThroughputExceededException Se ha superado el desempeño provisionado


máximo permitido.

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.

// 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
content-length: 409

{"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"]}
}

Versión de API 2012-08-10


1166
Amazon DynamoDB Guía para desarrolladores
BatchWriteItem

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

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
Esta operación permite colocar o eliminar varios elementos en una o varias tablas con una sola llamada.

Para cargar un elemento, puede utilizarPutItemPara eliminar un elemento, puede utilizarDeleteItem.


Sin embargo, si desea cargar o eliminar grandes cantidades de datos, como, por ejemplo, cargar grandes
cantidades de datos desde Amazon EMR (Amazon EMR) o migrar datos desde otra base de datos a
DynamoDB,BatchWriteItemofrece una alternativa eficiente.

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

Versión de API 2012-08-10


1167
Amazon DynamoDB Guía para desarrolladores
BatchWriteItem

Cuando utilice BatchWriteItem, tenga en cuenta las siguientes limitaciones:

• 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:

• Si una o varias tablas especificados en la solicitud BatchWriteItem no existe.


• Si los atributos de clave principal especificados en un elemento de la solicitud no coinciden con el
esquema de clave principal de la tabla correspondiente.
• Si intenta realizar varias operaciones con el mismo elemento en el mismoBatchWriteItemrequest. Por
ejemplo, no puede colocar y eliminar el mismo elemento en la misma solicitud BatchWriteItem.
• Si el tamaño total de la solicitud supera el límite de tamaño de solicitud de 1 MB (la carga de HTTP).
• Si cualquier elemento individual de un lote supera el límite de tamaño de elemento de 64 KB.

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, ... ],

Versión de API 2012-08-10


1168
Amazon DynamoDB Guía para desarrolladores
BatchWriteItem

"TableName2" : [ Request, Request, ... ],


...
}

Request ::=
PutRequest | DeleteRequest

PutRequest ::=
{
"PutRequest" : {
"Item" : {
"Attribute-Name1" : Attribute-Value,
"Attribute-Name2" : Attribute-Value,
...
}
}
}

DeleteRequest ::=
{
"DeleteRequest" : {
"Key" : PrimaryKey-Value
}
}

PrimaryKey-Value ::= HashTypePK | HashAndRangeTypePK

HashTypePK ::=
{
"HashKeyElement" : Attribute-Value
}

HashAndRangeTypePK
{
"HashKeyElement" : Attribute-Value,
"RangeKeyElement" : Attribute-Value,
}

Attribute-Value ::= String | Numeric| Binary | StringSet | NumericSet | BinarySet

Numeric ::=
{
"N": "Number"
}

String ::=
{
"S": "String"
}

Binary ::=
{
"B": "Base64 encoded binary data"
}

StringSet ::=
{
"SS": [ "String1", "String2", ... ]
}

NumberSet ::=
{
"NS": [ "Number1", "Number2", ... ]
}

Versión de API 2012-08-10


1169
Amazon DynamoDB Guía para desarrolladores
BatchWriteItem

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:

• Colocar un elemento y eliminar un elemento de la tabla Reply


• Colocar un elemento en la tabla 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

Versión de API 2012-08-10


1170
Amazon DynamoDB Guía para desarrolladores
BatchWriteItem

{
"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

Versión de API 2012-08-10


1171
Amazon DynamoDB Guía para desarrolladores
CreateTable

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.

Use la operación DescribeTables (p. 1184) para comprobar el estado de la tabla.

Requests
Syntax

// This header is abbreviated.

Versión de API 2012-08-10


1172
Amazon DynamoDB Guía para desarrolladores
CreateTable

// For a sample of a complete header, see API de bajo nivel de DynamoDB.


POST / HTTP/1.1
x-amz-target: DynamoDB_20111205.CreateTable
content-type: application/x-amz-json-1.0

{"TableName":"Table1",
"KeySchema":
{"HashKeyElement":{"AttributeName":"AttributeName1","AttributeType":"S"},
"RangeKeyElement":{"AttributeName":"AttributeName2","AttributeType":"N"}},
"ProvisionedThroughput":{"ReadCapacityUnits":5,"WriteCapacityUnits":10}
}

Nombre Descripción Obligatorio

TableName Nombre de la tabla que se va a Sí


crear.

Los caracteres permitidos son


a-z, A-Z, 0-9, "_" (guion bajo),
"-" (guion) y "." (punto). Los
nombres pueden tener de 3 a
255 caracteres de longitud.

Type: Cadena

KeySchema Estructura de la clave principal Sí


(simple o compuesta) de la
tabla. Un par nombre-valor
para elHashKeyElementPara,
y un par nombre-valor para
elRangeKeyElementes opcional
(solo se requiere para claves
primarias compuestas). Para
obtener más información sobre
claves principales, consulte
Clave principal (p. 6).

Los nombres de elemento de


clave principal pueden tener
entre 1 y 255 caracteres y
no tienen restricciones de
caracteres.

Los valores posibles de


AttributeType son "S" (cadena),
"N" (numérico) o "B" (binario).

Type: Mapa
deHashKeyElement, o
bienHashKeyElementyRangeKeyElementPara
obtener una clave principal
compuesta.

ProvisionedThroughput Nuevo desempeño de la Sí


tabla especificada, que
se compone de valores
paraReadCapacityUnitsyWriteCapacityUnits.
Para obtener más información,
consulte Administración de

Versión de API 2012-08-10


1173
Amazon DynamoDB Guía para desarrolladores
CreateTable

Nombre Descripción Obligatorio


la configuración en tablas de
capacidad provisionadas de
DynamoDB (p. 350).
Note

Para obtener los


valores mínimo y
máximo actuales,
consulte Cuotas de
servicio, cuenta y
tabla en Amazon
DynamoDB (p. 1066).

Type: Matriz

ProvisionedThroughput: Establece el número mínimo Sí


ReadCapacityUnits deReadCapacityUnitsConsumido
por segundo para la tabla
especificada DynamoDB libre la
carga con otras operaciones.

Las operaciones de lectura


consistente final requieren menos
esfuerzo que una operación
de lectura consistente; por lo
tanto, un ajuste de 50 unidades
ReadCapacityUnits
consistentes por
segundo proporciona
100 unidades de capacidad
ReadCapacityUnits
consistentes finales por segundo.

Type: Número

ProvisionedThroughput: Establece el número mínimo Sí


WriteCapacityUnits deWriteCapacityUnitsConsumido
por segundo para la tabla
especificada DynamoDB libre la
carga con otras operaciones.

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,

Versión de API 2012-08-10


1174
Amazon DynamoDB Guía para desarrolladores
CreateTable

"KeySchema":
{"HashKeyElement":{"AttributeName":"AttributeName1","AttributeType":"S"},
"RangeKeyElement":{"AttributeName":"AttributeName2","AttributeType":"N"}},
"ProvisionedThroughput":{"ReadCapacityUnits":5,"WriteCapacityUnits":10},
"TableName":"Table1",
"TableStatus":"CREATING"
}
}

Nombre Descripción

TableDescription Contenedor de propiedades de la tabla.

CreationDateTime Fecha en que se creó la tabla en formato de


tiempo UNIX.

Type: Número

KeySchema Estructura de la clave principal (simple o


compuesta) de la tabla. Un par nombre-valor para
elHashKeyElementPara, y un par nombre-valor
para elRangeKeyElementes opcional (solo se
requiere para claves primarias compuestas). Para
obtener más información sobre claves principales,
consulte Clave principal (p. 6).

Type: Mapa deHashKeyElement, o


bienHashKeyElementyRangeKeyElementPara
obtener una clave principal compuesta.

ProvisionedThroughput Rendimiento de la tabla especificada,


que se compone de valores
paraReadCapacityUnitsyWriteCapacityUnits.
Consulte Administración de la configuración
en tablas de capacidad provisionadas de
DynamoDB (p. 350).

Type: Matriz

ProvisionedThroughput : número mínimo


:ReadCapacityUnits deReadCapacityUnitsConsumido por segundo
antes de DynamoDB. equilibre la carga con otras
operaciones.

Type: Número

ProvisionedThroughput : número mínimo


:WriteCapacityUnits deReadCapacityUnitsConsumido por segundo
antesWriteCapacityUnitsequilibre la carga con
otras operaciones.

Type: Número

TableName Nombre de la tabla creada.

Type: Cadena

TableStatus Estado actual de la tabla (CREATING). Una vez que


la tabla adquiere el estado ACTIVE, puede colocar
datos en ella.

Versión de API 2012-08-10


1175
Amazon DynamoDB Guía para desarrolladores
CreateTable

Nombre Descripción
Use el API DescribeTables (p. 1184) para
comprobar el estado de la tabla.

Type: Cadena

Errores especiales

Error Descripción

ResourceInUseException Se intentó volver a crear una tabla que ya existía.

LimitExceededException El número de solicitudes simultáneas para la


tabla (número acumulado de tablas que se
encuentren en los estados CREATING, DELETING
o UPDATING) supera el máximo permitido.
Note

Para obtener los valores mínimo y


máximo actuales, consulte Cuotas de
servicio, cuenta y tabla en Amazon
DynamoDB (p. 1066).
.

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

// 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.CreateTable
content-type: application/x-amz-json-1.0

{"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

Versión de API 2012-08-10


1176
Amazon DynamoDB Guía para desarrolladores
DeleteItem

{"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

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

// 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.DeleteItem
content-type: application/x-amz-json-1.0

{"TableName":"Table1",
"Key":
{"HashKeyElement":{"S":"AttributeValue1"},"RangeKeyElement":
{"N":"AttributeValue2"}},

Versión de API 2012-08-10


1177
Amazon DynamoDB Guía para desarrolladores
DeleteItem

"Expected":{"AttributeName3":{"Value":{"S":"AttributeValue3"}}},
"ReturnValues":"ALL_OLD"}
}

Nombre Descripción Obligatorio

TableName Nombre de la tabla que contiene Sí


el elemento que se va a eliminar.

Type: Cadena

Key Clave principal que define Sí


el elemento. Para obtener
más información sobre claves
principales, consulte Clave
principal (p. 6).

Type: Mapa
deHashKeyElementa su valor
yRangeKeyElementA su valor.

Expected Designa un atributo para No


una eliminación condicional.
LaExpectedEl parámetro
permite proporcionar un
nombre de atributo e indicar si
DynamoDB debe comprobar
si el atributo tiene un valor
determinado antes de eliminarlo.

Type: Map, mapa de nombres de


atributos.

Expected:AttributeName Nombre del atributo para la No


operación Put condicional.

Type: Cadena

Expected:AttributeName: Use este parámetro para No


ExpectedAttributeValue especificar si ya existe un valor
del par de nombre-valor del
atributo.

En la siguiente notación JSON,


se elimina el elemento si todavía
no existe el atributo "Color" para
ese elemento:

"Expected" :
{"Color":{"Exists":false}}

En la siguiente notación JSON


se comprueba si el atributo
denominado "Color" tiene el valor
"Yellow" antes de eliminar el
elemento:

"Expected" :

Versión de API 2012-08-10


1178
Amazon DynamoDB Guía para desarrolladores
DeleteItem

Nombre Descripción Obligatorio


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

ReturnValues Use este parámetro si desea No


obtener los pares de nombre-
valor de los atributos antes
de eliminarlos. Los valores
posibles de parámetros
sonNONE(predeterminado)
oALL_OLD. SiALL_OLDSe
especifica, se devolverá el
contenido del elemento anterior.
Si este parámetro no se
proporciona o si su valor es
NONE, no se devuelve nada.

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"]},

Versión de API 2012-08-10


1179
Amazon DynamoDB Guía para desarrolladores
DeleteItem

"AttributeName2":{"S":"AttributeValue2"},
"AttributeName1":{"N":"AttributeValue1"}
},
"ConsumedCapacityUnits":1
}

Nombre Descripción

Attributes Si el archivo deReturnValuesse proporciona


comoALL_OLDEn la solicitud, DynamoDB devuelve
una matriz de pares de nombre-valor del atributo
(es decir, el elemento eliminado). De lo contrario, la
respuesta contiene un conjunto vacío.

Type: Array; matriz de pares de nombre-valor.

ConsumedCapacityUnits Número de unidades de capacidad de escritura


consumidas por la operación. Este valor muestra
el número aplicado al desempeño provisionado.
Cada solicitud de eliminación de elementos
inexistentes consume una unidad de capacidad
de escritura. Para obtener más información,
consulteAdministración de la configuración
en tablas de capacidad provisionadas de
DynamoDB (p. 350).

Type: Número

Errores especiales

Error Descripción

ConditionalCheckFailedException Error en la comprobación condicional. No se


encontró un valor de atributo esperado.

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.DeleteItem
content-type: application/x-amz-json-1.0

{"TableName":"comp-table",
"Key":
{"HashKeyElement":{"S":"Mingus"},"RangeKeyElement":{"N":"200"}},
"Expected":
{"status":{"Value":{"S":"shopping"}}},
"ReturnValues":"ALL_OLD"
}

Versión de API 2012-08-10


1180
Amazon DynamoDB Guía para desarrolladores
DeleteTable

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.

Use la operación DescribeTables (p. 1184) para comprobar el estado de la tabla.

Requests
Syntax

// This header is abbreviated.

Versión de API 2012-08-10


1181
Amazon DynamoDB Guía para desarrolladores
DeleteTable

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

{"TableName":"Table1"}

Nombre Descripción Obligatorio

TableName Nombre de la tabla que se va a Sí


eliminar.

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

TableDescription Contenedor de propiedades de la tabla.

CreationDateTime Fecha de creación de la tabla.

Type: Número

KeySchema Estructura de la clave principal (simple o


compuesta) de la tabla. Un par nombre-valor para
elHashKeyElementPara, y un par nombre-valor
para elRangeKeyElementes opcional (solo se
requiere para claves primarias compuestas). Para
obtener más información sobre claves principales,
consulte Clave principal (p. 6).

Type: Mapa deHashKeyElement, o


bienHashKeyElementyRangeKeyElementPara
una clave principal compuesta.

ProvisionedThroughput Rendimiento de la tabla especificada,


que se compone de valores

Versión de API 2012-08-10


1182
Amazon DynamoDB Guía para desarrolladores
DeleteTable

Nombre Descripción
paraReadCapacityUnitsyWriteCapacityUnits.
Consulte Administración de la configuración
en tablas de capacidad provisionadas de
DynamoDB (p. 350).

ProvisionedThroughput: : número mínimo


ReadCapacityUnits deReadCapacityUnitsConsumido por segundo
para la tabla especificada DynamoDB libre la carga
con otras operaciones.

Type: Número

ProvisionedThroughput: : número mínimo


WriteCapacityUnits deWriteCapacityUnitsConsumido por segundo
para la tabla especificada DynamoDB libre la carga
con otras operaciones.

Type: Número

TableName Nombre de la tabla eliminada.

Type: Cadena

TableStatus Estado actual de la tabla (DELETING). Una vez que


se elimina la tabla, las solicitudes posteriores de la
tabla devuelven resource not found.

Use la operación DescribeTables (p. 1184) para


comprobar el estado de la tabla.

Type: Cadena

Errores especiales

Error Descripción

ResourceInUseException La tabla se encuentra en el estado CREATING o


UPDATING y no se puede eliminar.

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"}

Versión de API 2012-08-10


1183
Amazon DynamoDB Guía para desarrolladores
DescribeTables

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"}

Nombre Descripción Obligatorio

TableName Nombre de la tabla que se Sí


describe.

Type: Cadena

Versión de API 2012-08-10


1184
Amazon DynamoDB Guía para desarrolladores
DescribeTables

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

Table Contenedor de la tabla que se describe.

Type: Cadena

CreationDateTime Fecha en que se creó la tabla en formato de


tiempo UNIX.

ItemCount Número de elementos de la tabla especificada.


DynamoDB actualiza este valor aproximadamente
cada seis horas. Los cambios recientes podrían no
reflejarse en este valor.

Type: Número

KeySchema Estructura de la clave principal (simple o


compuesta) de la tabla. Un par nombre-valor para
elHashKeyElementPara, y un par nombre-valor
para elRangeKeyElementes opcional (solo se
requiere para claves primarias compuestas). El
tamaño máximo de la clave hash es de 2048 bytes.
El tamaño máximo de la clave de rango es de
1024 bytes. Ambos límites se aplican por separado
(es decir, puede disponer de una clave combinada
de rango y hash de 2048+1024). Para obtener
más información sobre claves principales, consulte
Clave principal (p. 6).

ProvisionedThroughput Rendimiento de la tabla especificada,


que se compone de valores
paraLastIncreaseDateTime(si
procede),LastDecreaseDateTime(si
procede),ReadCapacityUnitsyWriteCapacityUnits.
Si el desempeño de la tabla no se ha aumentado

Versión de API 2012-08-10


1185
Amazon DynamoDB Guía para desarrolladores
DescribeTables

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

TableName Nombre de la tabla solicitada.

Type: Cadena

TableSizeBytes Tamaño total de la tabla especificada, en bytes.


DynamoDB actualiza este valor aproximadamente
cada seis horas. Los cambios recientes podrían no
reflejarse en este valor.

Type: Número

TableStatus Estado actual de la tabla


(CREATING,ACTIVE,DELETINGorUPDATING). Una
vez que la tabla adquiere el estado ACTIVE, puede
agregarle datos.

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},

Versión de API 2012-08-10


1186
Amazon DynamoDB Guía para desarrolladores
GetItem

"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

// 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.GetItem
content-type: application/x-amz-json-1.0

{"TableName":"Table1",
"Key":
{"HashKeyElement": {"S":"AttributeValue1"},
"RangeKeyElement": {"N":"AttributeValue2"}
},
"AttributesToGet":["AttributeName3","AttributeName4"],
"ConsistentRead":Boolean
}

Nombre Descripción Obligatorio

TableName Nombre de la tabla que contiene Sí


el elemento solicitado.

Type: Cadena

Versión de API 2012-08-10


1187
Amazon DynamoDB Guía para desarrolladores
GetItem

Nombre Descripción Obligatorio

Key Valores de clave principal Sí


que definen el elemento. Para
obtener más información sobre
claves principales, consulte
Clave principal (p. 6).

Type: Mapa
deHashKeyElementa su valor
yRangeKeyElementA su valor.

AttributesToGet Matriz de nombres de atributo. Si No


no se especifican sus nombres,
se devuelven todos los atributos.
Si algún atributo no se encuentra,
no aparecerá en los resultados.

Type: Matriz

ConsistentRead Si se establece en true, se No


emite una lectura consistente;
en caso contrario, se utiliza una
lectura consistente final.

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

Item Contiene los atributos solicitados.

Type: Map, mapa de pares de nombre-valor.

ConsumedCapacityUnits Número de unidades de capacidad de lectura


consumidas por la operación. Este valor muestra
el número aplicado al desempeño provisionado.
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, consulteAdministración

Versión de API 2012-08-10


1188
Amazon DynamoDB Guía para desarrolladores
ListTables

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

// 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.GetItem
content-type: application/x-amz-json-1.0

{"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

Esta sección se refiere a la versión 2011-12-05 del API, que está


obsoleta y no debe utilizarse para nuevas aplicaciones.

Versión de API 2012-08-10


1189
Amazon DynamoDB Guía para desarrolladores
ListTables

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

// 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.ListTables
content-type: application/x-amz-json-1.0

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

Nombre Descripción Obligatorio

Limit Número máximo de nombres de No


tabla que se devolverán.

Type: Entero

ExclusiveStartTableName Nombre de la primera tabla de No


la lista. Si ya se ha ejecutado
una operación ListTables
y se ha recibido un valor
LastEvaluatedTableName en
la respuesta, use ese valor aquí
para continuar la lista.

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

Versión de API 2012-08-10


1190
Amazon DynamoDB Guía para desarrolladores
ListTables

{"TableNames":["Table1","Table2","Table3"], "LastEvaluatedTableName":"Table3"}

Nombre Descripción

TableNames Nombres de las tablas asociadas con la cuenta


actual en el punto de enlace actual.

Type: Matriz

LastEvaluatedTableName Nombre de la última tabla de la lista actual, pero


solo si no se han devuelto algunas tablas de
la cuenta y el punto de enlace. Este valor no
existe en una respuesta si ya se han devuelto
los nombres de todas las tablas. Use este valor
en ExclusiveStartTableName en una nueva
solicitud para continuar la lista hasta que se hayan
devuelto los nombres de todas las tablas.

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

// 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.ListTables
content-type: application/x-amz-json-1.0

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

Versión de API 2012-08-10


1191
Amazon DynamoDB Guía para desarrolladores
PutItem

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

// 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":"Table1",
"Item":{
"AttributeName1":{"S":"AttributeValue1"},
"AttributeName2":{"N":"AttributeValue2"},
"AttributeName5":{"B":"dmFsdWU="}
},
"Expected":{"AttributeName3":{"Value": {"S":"AttributeValue"}, "Exists":Boolean}},
"ReturnValues":"ReturnValuesConstant"}

Nombre Descripción Obligatorio

TableName Nombre de la tabla que Sí


contendrá el elemento.

Type: Cadena

Item Mapa de los atributos del Sí


elemento, que debe incluir
los valores de clave principal
que definen el elemento. Se

Versión de API 2012-08-10


1192
Amazon DynamoDB Guía para desarrolladores
PutItem

Nombre Descripción Obligatorio


pueden indicar otros pares de
nombre-valor de los atributos
del elemento. Para obtener
más información sobre claves
principales, consulte Clave
principal (p. 6).

Type: Map, mapa de nombres de


atributos a valores de atributos.

Expected Designa un atributo para No


una colocación condicional.
LaExpectedEl parámetro
permite proporcionar un
nombre de atributo e indicar si
DynamoDB debe comprobar si el
valor del atributo ya existe; o bien
si el valor del atributo existe y
tiene un valor determinado antes
de cambiarlo.

Type: Map, mapa de nombres


de un atributo a valores de un
atributo e indicación de si existe.

Expected:AttributeName Nombre del atributo para la No


operación Put condicional.

Type: Cadena

Versión de API 2012-08-10


1193
Amazon DynamoDB Guía para desarrolladores
PutItem

Nombre Descripción Obligatorio

Expected:AttributeName: Use este parámetro para No


ExpectedAttributeValue especificar si ya existe un valor
del par de nombre-valor del
atributo.

En la siguiente notación JSON,


se sustituye el elemento si
todavía no existe el atributo
"Color" para ese elemento:

"Expected" :
{"Color":{"Exists":false}}

En la siguiente notación JSON


se comprueba si el atributo
denominado "Color" tiene el valor
"Yellow" antes de sustituir el
elemento:

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

Versión de API 2012-08-10


1194
Amazon DynamoDB Guía para desarrolladores
PutItem

Nombre Descripción Obligatorio

ReturnValues Use este parámetro si desea No


obtener los pares de nombre-
valor de los atributos antes
de actualizarlos mediante el
parámetroPutItemrequest. Los
valores posibles de parámetros
sonNONE(predeterminado)
oALL_OLD. SiALL_OLDSe
especifica, yPutItemha
sobrescrito un par de nombre-
valor del atributo, se devuelve
el contenido del elemento
anterior. Si este parámetro no
se proporciona o si su valor es
NONE, no se devuelve nada.

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

Attributes Valores de los atributos antes de la operación


de colocación, pero solamente si el parámetro
ReturnValues se especifica como ALL_OLD en la
solicitud.

Type: Map, mapa de pares de nombre-valor.

ConsumedCapacityUnits Número de unidades de capacidad de escritura


consumidas por la operación. Este valor muestra el
número aplicado al desempeño provisionado. Para
obtener más información, consulteAdministración
de la configuración en tablas de capacidad
provisionadas de DynamoDB (p. 350).

Versión de API 2012-08-10


1195
Amazon DynamoDB Guía para desarrolladores
PutItem

Nombre Descripción
Type: Número

Errores especiales

Error Descripción

ConditionalCheckFailedException Error en la comprobación condicional. No se


encontró un valor de atributo esperado.

ResourceNotFoundException No se encontró el elemento o atributo especificado.

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)

Versión de API 2012-08-10


1196
Amazon DynamoDB Guía para desarrolladores
Query

• GetItem (p. 1187)


• BatchGetItem (p. 1162)

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

// 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":"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"]},
}

Versión de API 2012-08-10


1197
Amazon DynamoDB Guía para desarrolladores
Query

Nombre Descripción Obligatorio

TableName Nombre de la tabla que contiene Sí


los elementos solicitados.

Type: Cadena

AttributesToGet Matriz de nombres de atributo. Si No


no se especifican sus nombres,
se devuelven todos los atributos.
Si algún atributo no se encuentra,
no aparecerá en los resultados.

Type: Matriz

Limit Número máximo de elementos No


que se devolverán, que no es
necesariamente el número de
elementos coincidentes. Si
DynamoDB alcanza el límite del
número de elementos mientras
consulta la tabla, detiene la
consulta y devuelve los valores
coincidentes hasta ese punto,
junto con el valor de, que
puede aplicarse un valor de,
que puede aplicarse un valor
de.LastEvaluatedKeypara
aplicar en una operación
posterior para continuar
con la consulta. Además,
si el tamaño del conjunto
de resultados supera 1 MB
antes de que DynamoDB
alcance este límite, detiene la
consulta y devuelve los valores
coincidentes, junto con una
excepciónLastEvaluatedKeypara
aplicar en una operación
posterior para continuar con la
consulta.

Type: Número

ConsistentRead Si se establece en true, se No


emite una lectura consistente;
en caso contrario, se utiliza una
lectura consistente final.

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

Versión de API 2012-08-10


1198
Amazon DynamoDB Guía para desarrolladores
Query

Nombre Descripción Obligatorio


parámetro Limit a las consultas
que son solo de recuento.

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

HashKeyValue Valor de atributo del componente Sí


hash de la clave principal
compuesta.

Type: String, Number o Binary

RangeKeyCondition Contenedor de los valores de No


los atributos y operadores de
comparación que se usarán
en la consulta. Una solicitud
de consulta no requiere
unRangeKeyCondition.
Si proporciona solo
laHashKeyValue, DynamoDB
devuelve todos los elementos
que tienen el valor especificado
de clave hash.

Type: Map

RangeKeyCondition: Valores de los atributos que No


AttributeValueList se van a evaluar para los
parámetros de la consulta.
LaAttributeValueListcontiene
un valor de atributo, a no ser
queBETWEENse especifica
la comparación. Para la
comparación BETWEEN, la lista
AttributeValueList contiene
dos valores de atributos.

Type: Mapa de imágenes


()AttributeValuea
unComparisonOperator.

Versión de API 2012-08-10


1199
Amazon DynamoDB Guía para desarrolladores
Query

Nombre Descripción Obligatorio

RangeKeyCondition: Criterios para evaluar los No


ComparisonOperator atributos proporcionados, tales
como igual que, mayor que, etc.
A continuación se muestran los
operadores de comparación
válidos para una operación
Query.
Note

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.

Type: String o Binary

EQ: igual que.

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

Versión de API 2012-08-10


1200
Amazon DynamoDB Guía para desarrolladores
Query

Nombre Descripción Obligatorio

LE: menor o igual que.

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

GE: mayor o igual que.

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

Versión de API 2012-08-10


1201
Amazon DynamoDB Guía para desarrolladores
Query

Nombre Descripción Obligatorio

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

BETWEEN: mayor o igual que el


primer valor y menor o igual que
el segundo valor.

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

Versión de API 2012-08-10


1202
Amazon DynamoDB Guía para desarrolladores
Query

Nombre Descripción Obligatorio

ScanIndexForward Especifica si el índice se No


recorrerá en sentido ascendente
o descendente. DynamoDB
devuelve resultados que reflejan
el orden solicitado determinado
por la clave de rango: Si el
tipo de datos es Number, los
resultados se devuelven en
orden numérico; de lo contrario,
el recorrido se basa en los
valores del código de caracteres
ASCII.

Type: Booleano

El valor predeterminado es true


(ascendente).

ExclusiveStartKey Clave principal del elemento No


a partir del cual se continuará
una consulta anterior. Una
consulta anterior podría
proporcionar este valor
comoLastEvaluatedKeySi
la operación de consulta
se interrumpió antes de
completar la consulta, ya
sea debido al tamaño del
conjunto de resultados o al valor
deLimitParámetro. El valor de
LastEvaluatedKey se puede
pasar a una nueva solicitud
de consulta para continuar la
operación a partir de ese punto.

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"}
},{

Versión de API 2012-08-10


1203
Amazon DynamoDB Guía para desarrolladores
Query

"AttributeName1":{"S":"AttributeValue3"},
"AttributeName2":{"N":"AttributeValue4"},
"AttributeName3":{"S":"AttributeValue3"},
"AttributeName5":{"B":"dmFsdWU="}
}],
"LastEvaluatedKey":{"HashKeyElement":{"AttributeValue3":"S"},
"RangeKeyElement":{"AttributeValue4":"N"}
},
"ConsumedCapacityUnits":1
}

Nombre Descripción

Items Atributos de elementos que cumplen los


parámetros de la consulta.

Type: Map, mapa de los nombres de atributos y


sus tipos de datos y valores.

Count Número de elementos de la respuesta. Para


obtener más información, consulte Recuento de los
elementos de los resultados (p. 502) .

Type: Número

LastEvaluatedKey Clave principal del elemento en el que se ha


detenido la operación de consulta, incluido el
conjunto de resultados anterior. Utilice este valor
para iniciar una nueva operación excluyendo este
valor en la nueva solicitud.

El valor de LastEvaluatedKey es null cuando


se ha completado todo el conjunto de resultados
de la consulta (es decir, cuando la operación ha
procesado la “última página”).

Tipo: HashKeyElement, o bien HashKeyElement


y RangeKeyElement si se trata de una clave
principal compuesta.

ConsumedCapacityUnits Número de unidades de capacidad de lectura


consumidas por la operación. Este valor muestra el
número aplicado al desempeño provisionado. Para
obtener más información, consulteAdministración
de la configuración en tablas de capacidad
provisionadas de DynamoDB (p. 350).

Type: Número

Errores especiales

Error Descripción

ResourceNotFoundException No se encontró la tabla especificada.

Versión de API 2012-08-10


1204
Amazon DynamoDB Guía para desarrolladores
Query

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}

Versión de API 2012-08-10


1205
Amazon DynamoDB Guía para desarrolladores
Scan

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"}

Versión de API 2012-08-10


1206
Amazon DynamoDB Guía para desarrolladores
Scan

},
"ExclusiveStartKey":{
"HashKeyElement":{"S":"AttributeName1"},
"RangeKeyElement":{"N":"AttributeName2"}
},
"AttributesToGet":["AttributeName1", "AttributeName2", "AttributeName3"]},
}

Nombre Descripción Obligatorio

TableName Nombre de la tabla que contiene Sí


los elementos solicitados.

Type: Cadena

AttributesToGet Matriz de nombres de atributo. Si No


no se especifican sus nombres,
se devuelven todos los atributos.
Si algún atributo no se encuentra,
no aparecerá en los resultados.

Type: Matriz

Limit Número máximo de elementos No


que se van a evaluar, que no
es necesariamente el número
de elementos coincidentes. Si
DynamoDB alcanza el límite
del número de elementos
mientras procesa los resultados,
detiene y devuelve los valores
coincidentes hasta ese punto,
junto con el valor de, que
puede aplicarse un valor de,
que puede aplicarse un valor
deLastEvaluatedKeypara
aplicar en una operación
posterior para continuar
recuperando elementos.
Además, si el tamaño del
conjunto de datos examinados
supera 1 MB antes de que
DynamoDB alcance este
límite, detiene el examen y
devuelve los valores coincidentes
hasta el límite, junto con el
valor de, que puede aplicarse
unLastEvaluatedKeypara
aplicar en una operación
posterior para continuar el
análisis.

Type: Número

Count Si se establece entrueAdemás, No


DynamoDB devuelve un
número total de elementos de
la operación Scan, aunque no

Versión de API 2012-08-10


1207
Amazon DynamoDB Guía para desarrolladores
Scan

Nombre Descripción Obligatorio


encuentre ningún elemento
coincidente para el filtro
asignado. Puede aplicar el
parámetro Limit a los exámenes
que son solo de recuento.

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

ScanFilter Evalúa los resultados del examen No


y solo devuelve los valores
deseados. Si se especifican
varias condiciones, se tratan
como operaciones "AND":
deberán cumplirse todas las
condiciones para que se incluyan
en los resultados.

Type: Un mapa de nombres


de atributos a valores con
operadores de comparación.

Valores y condiciones que


ScanFilter:AttributeValueList No
se usarán para evaluar los
resultados del examen para el
filtro.

Type: Mapa de imágenes


()AttributeValuea
unCondition.

Versión de API 2012-08-10


1208
Amazon DynamoDB Guía para desarrolladores
Scan

Nombre Descripción Obligatorio

ScanFilter: Criterios para evaluar los No


ComparisonOperator atributos proporcionados, tales
como igual que, mayor que, etc.
A continuación se muestran los
operadores de comparación
válidos para una operación de
examen.
Note

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.

Type: String o Binary

EQ: igual que.

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

Versión de API 2012-08-10


1209
Amazon DynamoDB Guía para desarrolladores
Scan

Nombre Descripción Obligatorio

NE: distinto de.

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

LE: menor o igual que.

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

Versión de API 2012-08-10


1210
Amazon DynamoDB Guía para desarrolladores
Scan

Nombre Descripción Obligatorio

GE: mayor o igual que.

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

NOT_NULL: el atributo existe.

NULL: el atributo no existe.

Versión de API 2012-08-10


1211
Amazon DynamoDB Guía para desarrolladores
Scan

Nombre Descripción Obligatorio

CONTAINS: comprueba si hay


una subsecuencia, o un valor en
un conjunto.

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

Versión de API 2012-08-10


1212
Amazon DynamoDB Guía para desarrolladores
Scan

Nombre Descripción Obligatorio

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

IN: comprueba si hay


coincidencias exactas.

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.

BETWEEN: mayor o igual que el


primer valor y menor o igual que
el segundo valor.

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

Versión de API 2012-08-10


1213
Amazon DynamoDB Guía para desarrolladores
Scan

Nombre Descripción Obligatorio

ExclusiveStartKey Clave principal del elemento a No


partir del cual se continuará un
examen anterior. Un examen
anterior puede proporcionar
este valor si la operación de
examen se interrumpió antes
de examinar toda la tabla;
ya sea debido al tamaño del
conjunto de resultados o al valor
deLimitParámetro. El valor de
LastEvaluatedKey se puede
pasar a una nueva solicitud
de examen para continuar la
operación a partir de ese punto.

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

Items Contenedor de los atributos que coinciden con los


parámetros de la operación.

Type: Map, mapa de los nombres de atributos y


sus tipos de datos y valores.

Versión de API 2012-08-10


1214
Amazon DynamoDB Guía para desarrolladores
Scan

Nombre Descripción

Count Número de elementos de la respuesta. Para


obtener más información, consulte Recuento de los
elementos de los resultados (p. 518) .

Type: Número

ScannedCount Número de elementos del análisis completo


antes de aplicar cualquier filtro. Una
altaScannedCountValor de pocos, o
ninguno,Countindica que la operación Scan ha
sido ineficiente. Para obtener más información,
consulte Recuento de los elementos de los
resultados (p. 518) .

Type: Número

LastEvaluatedKey Clave principal del elemento en que se detuvo la


operación de examen. Proporcione este valor en
una operación de examen posterior para continuar
la operación a partir de ese punto.

El valor de LastEvaluatedKey es null cuando


se ha completado todo el conjunto de resultados
de examen (es decir, cuando la operación ha
procesado la "última página").

ConsumedCapacityUnits Número de unidades de capacidad de lectura


consumidas por la operación. Este valor muestra el
número aplicado al desempeño provisionado. Para
obtener más información, consulteAdministración
de la configuración en tablas de capacidad
provisionadas de DynamoDB (p. 350).

Type: Número

Errores especiales

Error Descripción

ResourceNotFoundException No se encontró la tabla especificada.

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

Versión de API 2012-08-10


1215
Amazon DynamoDB Guía para desarrolladores
Scan

{"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,

Versión de API 2012-08-10


1216
Amazon DynamoDB Guía para desarrolladores
Scan

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

Versión de API 2012-08-10


1217
Amazon DynamoDB Guía para desarrolladores
UpdateItem

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 un elemento tiene la clave principal especificada:

• PUT...Añade el atributo especificado. Si el atributo existe, se sustituye por el nuevo valor.


• DELETING (DELETING)Si no se especifica ningún valor, esta acción elimina el atributo y su valor. Si
se especifica un conjunto de valores, entonces los valores del conjunto especificado se eliminan del
conjunto anterior. Por lo tanto, si el valor del atributo contiene [a,b,c] y la acción de eliminación contiene
[a,c], el valor del atributo final es [b]. El tipo del valor especificado debe coincidir con el tipo de valor
existente. No es válido especificar un conjunto vacío.
• ADD...Use la acción de adición para números o si el atributo de destino es un conjunto (incluidos los
conjuntos de cadena). ADD no funciona si el atributo de destino es un valor de cadena única o un valor
escalar de tipo Binary. El valor especificado se suma a un valor numérico (se suma o se resta al valor
numérico existente) o se agrega como valor adicional a un conjunto de cadenas. Si se especifica un
conjunto de valores, los valores se agregan al conjunto existente. Por ejemplo, si el conjunto original es
[1,2] y el valor suministrado es [3], después de la operación de adición el conjunto será [1,2,3] y no [4,5].
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.

Si utiliza ADD para un atributo que no existe, el atributo y sus valores se agregan al elemento.

Si no hay ningún elemento que coincida con la clave principal especificada:

• 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

Versión de API 2012-08-10


1218
Amazon DynamoDB Guía para desarrolladores
UpdateItem

usandoADDDynamoDB utiliza para sumar o restar de un valor numérico de un atributo que no


existía antes de la actualización (pero el elemento sí existía)0como valor inicial. Por ejemplo,
usaADDAdd+3A un atributo que no existía antes de la actualización. usa DynamoDB0Para el valor
inicial, y el valor posterior a la actualización será3.

Para obtener más información sobre cómo usar esta operación, consulte Uso de elementos y
atributos (p. 410).

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.UpdateItem
content-type: application/x-amz-json-1.0

{"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"
}

Nombre Descripción Obligatorio

TableName Nombre de la tabla que contiene Sí


el elemento que se va a
actualizar.

Type: Cadena

Key Clave principal que define Sí


el elemento. Para obtener
más información sobre claves
principales, consulte Clave
principal (p. 6).

Type: Mapa
deHashKeyElementa su valor
yRangeKeyElementA su valor.

AttributeUpdates Mapa del nombre de atributo  


al nuevo valor y acción de la
actualización. Los nombres de
los atributos especifican los
atributos que hay que modificar y
no pueden contener atributos de
clave principal.

Type: Map, mapa de nombre


de atributo, valor y acción de la
actualización del atributo.

Versión de API 2012-08-10


1219
Amazon DynamoDB Guía para desarrolladores
UpdateItem

Nombre Descripción Obligatorio

AttributeUpdates:Action Especifica cómo realizar No


la actualización. Valores
posibles:PUT(predeterminado),ADDorDELETE.
La semántica se explica en la
descripción de UpdateItem.

Type: Cadena

Valor predeterminado: PUT

Expected Designa un atributo para una No


actualización condicional.
LaExpectedEl parámetro
permite proporcionar un
nombre de atributo e indicar si
DynamoDB debe comprobar si el
valor del atributo ya existe; o bien
si el valor del atributo existe y
tiene un valor determinado antes
de cambiarlo.

Type: Map, mapa de nombres de


atributos.

Expected:AttributeName Nombre del atributo para la No


operación Put condicional.

Type: Cadena

Versión de API 2012-08-10


1220
Amazon DynamoDB Guía para desarrolladores
UpdateItem

Nombre Descripción Obligatorio

Expected:AttributeName: Use este parámetro para No


ExpectedAttributeValue especificar si ya existe un valor
del par de nombre-valor del
atributo.

En la siguiente notación JSON,


se actualiza el elemento si
todavía no existe el atributo
"Color" para ese elemento:

"Expected" :
{"Color":{"Exists":false}}

En la siguiente notación JSON


se comprueba si el atributo
denominado "Color" tiene el valor
"Yellow" antes de actualizar el
elemento:

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

Versión de API 2012-08-10


1221
Amazon DynamoDB Guía para desarrolladores
UpdateItem

Nombre Descripción Obligatorio

ReturnValues Use este parámetro si desea No


obtener los pares de nombre-
valor de los atributos antes
de actualizarlos mediante el
parámetroUpdateItemrequest.
Los valores posibles
de parámetros
sonNONE(predeterminado)
oALL_OLD,UPDATED_OLD,ALL_NEWorUPDATED_NEW.
SiALL_OLDSe especifica,
yUpdateItemha sobrescrito
un par de nombre-valor del
atributo, se devuelve el contenido
del elemento anterior. Si este
parámetro no se proporciona o si
su valor es NONE, no se devuelve
nada. SiALL_NEWSe especifica,
entonces se devuelven todos
los atributos de la nueva versión
del elemento. Si se especifica
UPDATED_NEW, entonces se
devuelven solamente las nuevas
versiones de los atributos
actualizados.

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

Attributes Mapa de pares de nombre-valor del atributo,


pero solo si el parámetro ReturnValues se ha

Versión de API 2012-08-10


1222
Amazon DynamoDB Guía para desarrolladores
UpdateItem

Nombre Descripción
especificado como algo distinto de NONE en la
solicitud.

Type: Map, mapa de pares de nombre-valor.

ConsumedCapacityUnits Número de unidades de capacidad de escritura


consumidas por la operación. Este valor muestra el
número aplicado al desempeño provisionado. Para
obtener más información, consulteAdministración
de la configuración en tablas de capacidad
provisionadas de DynamoDB (p. 350).

Type: Número

Errores especiales
Error Descripción

ConditionalCheckFailedException Error en la comprobación condicional. El valor


del atributo ("+ name +") es ("+ value +") pero se
esperaba ("+ expValue +").

ResourceNotFoundExceptions No se encontró el elemento o atributo especificado.

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":

Versión de API 2012-08-10


1223
Amazon DynamoDB Guía para desarrolladores
UpdateTable

{"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

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

// 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.UpdateTable
content-type: application/x-amz-json-1.0

{"TableName":"Table1",
"ProvisionedThroughput":{"ReadCapacityUnits":5,"WriteCapacityUnits":15}
}

Nombre Descripción Obligatorio

TableName Nombre de la tabla que se va a Sí


actualizar.

Versión de API 2012-08-10


1224
Amazon DynamoDB Guía para desarrolladores
UpdateTable

Nombre Descripción Obligatorio


Type: Cadena

ProvisionedThroughput Nuevo desempeño de la Sí


tabla especificada, que
se compone de valores
paraReadCapacityUnitsyWriteCapacityUnits.
Consulte Administración de
la configuración en tablas de
capacidad provisionadas de
DynamoDB (p. 350).

Type: Matriz

ProvisionedThroughput Establece el número mínimo Sí


:ReadCapacityUnits deReadCapacityUnitsConsumido
por segundo para la tabla
especificada DynamoDB libre la
carga con otras operaciones.

Las operaciones de lectura


consistente final requieren menos
esfuerzo que una operación
de lectura consistente; por lo
tanto, un ajuste de 50 unidades
ReadCapacityUnits
consistentes por
segundo proporciona
100 unidades de capacidad
ReadCapacityUnits
consistentes finales por segundo.

Type: Número

ProvisionedThroughput Establece el número mínimo Sí


:WriteCapacityUnits deWriteCapacityUnitsConsumido
por segundo para la tabla
especificada DynamoDB libre la
carga con otras operaciones.

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"}},

Versión de API 2012-08-10


1225
Amazon DynamoDB Guía para desarrolladores
UpdateTable

"ProvisionedThroughput":
{"LastDecreaseDateTime":1.321661704489E9,
"LastIncreaseDateTime":1.321663607695E9,
"ReadCapacityUnits":5,
"WriteCapacityUnits":10},
"TableName":"Table1",
"TableStatus":"UPDATING"}}

Nombre Descripción

CreationDateTime Fecha de creación de la tabla.

Type: Número

KeySchema Estructura de la clave principal (simple o


compuesta) de la tabla. Un par nombre-valor para
elHashKeyElementPara, y un par nombre-valor
para elRangeKeyElementes opcional (solo se
requiere para claves primarias compuestas). El
tamaño máximo de la clave hash es de 2048 bytes.
El tamaño máximo de la clave de rango es de
1024 bytes. Ambos límites se aplican por separado
(es decir, puede disponer de una clave combinada
de rango y hash de 2048+1024). Para obtener
más información sobre claves principales, consulte
Clave principal (p. 6).

Type: Mapa deHashKeyElement, o


bienHashKeyElementyRangeKeyElementPara
una clave principal compuesta.

ProvisionedThroughput Ajustes de desempeño actuales de la


tabla especificada, incluidos los valores de
LastIncreaseDateTime (si procede) y
LastDecreaseDateTime (si procede).

Type: Matriz

TableName Nombre de la tabla actualizada.

Type: Cadena

TableStatus Estado actual de la tabla (CREATING, ACTIVE,


DELETING o UPDATING), que debe ser UPDATING.

Use la operación DescribeTables (p. 1184) para


comprobar el estado de la tabla.

Type: Cadena

Errores especiales

Error Descripción

ResourceNotFoundException No se encontró la tabla especificada.

ResourceInUseException La tabla no se encuentra en el estado ACTIVE.

Versión de API 2012-08-10


1226
Amazon DynamoDB Guía para desarrolladores
UpdateTable

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.UpdateTable
content-type: application/x-amz-json-1.0

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

Versión de API 2012-08-10


1227
Amazon DynamoDB Guía para desarrolladores

Historial de revisión de DynamoDB


En la tabla siguiente se describen los cambios importantes de cada versión de laGuía para desarrolladores
de DynamoDBA partir del 3 de julio de 2018. Para recibir notificaciones sobre las actualizaciones de esta
documentación, suscríbase a la fuente RSS (en la esquina superior izquierda de esta página).

update-history-change update-history-description update-history-date

Instancias de Amazon EC2 T3 DAX ya admiteTipos de 15 de febrero de 2021


para DAX (p. 1228) instancias de Amazon EC2 T3,
que proporcionan un nivel básico
de desempeño de la CPU con
la posibilidad de ampliarse por
encima del nivel básico cuando
sea necesario.

Compatibilidad NoSQL Ahora puede utilizar elNoSQL 4 de diciembre de 2020


Workbench para Amazon Workbench para DynamoDBPara
DynamoDB para crearPartiQLde DynamoDB.
PartiQL (p. 1228)

PartiQL para Ahora puede usarPartiQL para 23 de noviembre de 2020


DynamoDB (p. 1228) DynamoDB, un lenguaje de
consulta compatible con SQL,
para interactuar con tablas
de DynamoDB y ejecutar
consultas ad hoc mediante el
comandoAWS Management
Console,AWS Command Line
Interfacey las API de DynamoDB
para PartiQL.

Amazon Kinesis Data Ahora puede usarAmazon 23 de noviembre de 2020


Streams para Amazon Kinesis Data Streams para
DynamoDB (p. 1228) Amazon DynamoDBcon las
tablas de DynamoDB para
capturar los cambios a nivel de
elemento y replicarlos en una
secuencia de datos de Kinesis.

Exportar tabla de Ahora puedeExportación de 9 de noviembre de 2020


DynamoDB (p. 1228) tablas de DynamoDB a Amazon
S3, lo que le permite realizar
análisis y consultas complejas
sobre sus datos con servicios
como Athena,AWS Glue, y Lake
Formation.

Support con valores DynamoDB ahora admite valores 18 de mayo de 2020


vacíos (p. 1228) vacíos para atributos de cadena
y binarios que no son clave
en tablas de DynamoDB. La
compatibilidad con valores vacíos
le brinda mayor flexibilidad para
usar atributos para un conjunto

Versión de API 2012-08-10


1228
Amazon DynamoDB Guía para desarrolladores

más amplio de casos de uso sin


tener que transformar dichos
atributos antes de enviarlos a
DynamoDB. Los tipos de datos
List, Map y Set también admiten
valores de cadena y binarios
vacíos.

Compatibilidad NoSQL NoSQL Workbench for Amazon 4 de mayo de 2020


Workbench para Amazon DynamoDB ya se admite
DynamoDB para Linux (p. 1228) enLinux: Ubuntu, Fedora y
Debian.

Descripción de CloudWatch Descripción de CloudWatch 2 de abril de 2020


Contributor Insights for Contributor Insights for
DynamoDB — GA (p. 1228) DynamoDBestá disponible con
carácter general. CloudWatch
Colabortor Insights para
DynamoDB es una herramienta
de diagnóstico que proporciona
una vista rápida de las
tendencias del tráfico de su
tabla de DynamoDB y le ayuda
a identificar las claves a las que
se accede con más frecuencia
(también conocidas como teclas
rápidas)

Actualización de tablas Ahora puede actualizar sus 16 de marzo de 2020


globales (p. 1228) tablas globales de la versión
2017.11.29 a laVersión más
reciente de tablas globales
(2019.11.21), con unos
pocos clics en la consola de
DynamoDB. Al actualizar
la versión de las tablas
globales, puede aumentar la
disponibilidad de las tablas
de DynamoDB fácilmente
ampliando las tablas existentes
a otrasAWSRegiones, sin
necesidad de reconstrucciones
de tabla.

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.

Métricas de clúster de caché de Compatibilidad con DAX 6 de febrero de 2020


DAX (p. 1228) paraMétricas de CloudWatch,
que le permiten comprender
mejor el rendimiento de su clúster
DAX.

Versión de API 2012-08-10


1229
Amazon DynamoDB Guía para desarrolladores

Descripción de CloudWatch Descripción de CloudWatch 26 de noviembre de 2019


Contributor Insights for Contributor Insights for
DynamoDB — Vista DynamoDBes una herramienta
previa (p. 1228) de diagnóstico que proporciona
una vista rápida de las
tendencias de tráfico de su tabla
de DynamoDB y le ayuda a
identificar las claves a las que
se accede con más frecuencia
(también conocidas como teclas
rápidas)

Soporte de capacidad adaptable Capacidad adaptable de Amazon 26 de noviembre de 2019


para cargas de trabajo DynamoDB ahoraHandlescargas
desequilibradas (p. 1228) de trabajo desequilibradas
mejor al aislar automáticamente
los elementos a los que se
accede con frecuencia. Si su
aplicación dirige un tráfico alto
hacia uno o dos elementos
de forma desproporcionada,
DynamoDB volverá a equilibrar
sus particiones de manera
que los elementos con acceso
frecuente no residan en la misma
partición.

Support para CMK administradas ya DynamoDBadmite CMK 25 de noviembre de 2019


por el cliente (p. 1228) administradas por el cliente, lo
que significa que puede tener
control total sobre cómo cifrar y
administrar la seguridad de sus
datos de DynamoDB.

Compatibilidad con NoSQL Workbench ahora 8 de noviembre de 2019


NoSQL Workbench admite conectarse a DynamoDB
paraDynamoDB Local (versión Local (versión descargable)
descargable) (p. 1228) para diseñar, crear, consultar y
administrar tablas de DynamoDB.

NoSQL Workbench - Vista Es la versión inicial de NoSQL 16 de septiembre de 2019


previa (p. 1228) Workbench para DynamoDB.
Utilice NoSQL Workbench
para diseñar, crear, consultar y
administrar tablas de DynamoDB.
Para obtener más información,
consulte NoSQL Workbench
para Amazon DynamoDB (vista
previa).

Amazon DynamoDB Accelerator DAX 14 de febrero de 2019


(DAX) incorpora compatibilidad admiteTransactWriteItemsyTransactGetItemsAPI
con operaciones transaccionales de aplicaciones escritas en Go,
con Python y .NET (p. 1228) Java, .NET, Node.js y Python.
Para obtener más información,
consulte Acceleration en
memoria con DAX.

Versión de API 2012-08-10


1230
Amazon DynamoDB Guía para desarrolladores

Actualizaciones de Amazon DynamoDB Local (versión 4 de febrero de 2019


DynamoDB Local (versión descargable) admite ahora API
descargable) (p. 1228) transaccionales, capacidad de
lectura/escritura bajo demanda,
informes de capacidad para
las operaciones de lectura
y escritura, y 20 índices
secundarios globales. Para
obtener más información,
consulte Diferencias entre
la versión descargable de
DynamoDB y el servicio web de
DynamoDB.

Amazon DynamoDB bajo DynamoDB bajo demanda es 28 de noviembre de 2018


demanda (p. 1228) una opción de facturación flexible
que permite atender a miles
de solicitudes por segundo sin
tener que planificar la capacidad.
DynamoDB bajo demanda ofrece
precios de pago por solicitud
para las solicitudes de lectura
y escritura. De este modo,
únicamente tendrá que pagar por
aquello que utilice. Para obtener
más información, consulte Modo
de capacidad de lectura/escritura.

Transacciones de Amazon Las transacciones de DynamoDB 27 de noviembre de 2018


DynamoDB (p. 1228) realizan cambios coordinados
de tipo "todo o nada" en varios
elementos de la misma o de
distintas tablas. De este modo,
aportan atomicidad, consistencia,
aislamiento y durabilidad (ACID)
en DynamoDB. Para obtener
más información, consulte
Transacciones de Amazon
DynamoDB.

Amazon DynamoDB cifra El cifrado en reposo de 15 de noviembre de 2018


todos los datos en reposo del DynamoDB proporciona una
cliente (p. 1228) 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 DAX siempre que
los datos se almacenen en un
soporte duradero. Para obtener
más información, consulte
Cifrado en reposo de Amazon
DynamoDB.

Versión de API 2012-08-10


1231
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

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.

DynamoDB ator (DAX) incorpora Ahora, Amazon DynamoDB 9 de agosto de 2018


la Support el cifrado en Accelerator (DAX) admite el
reposo (p. 1228) cifrado en reposo para los
nuevos clústeres DAX. De este
modo, le ayuda a acelerar las
lecturas de las tablas de Amazon
DynamoDB en aplicaciones
sensibles a la seguridad sujetas
a estrictos requisitos normativos
y de cumplimiento. Para obtener
más información, consulte
Cifrado en reposo de DAX.

La recuperación a un momento Si elimina una tabla con la 7 de agosto de 2018


dado (PITR) de DynamoDB característica de recuperación
añade compatibilidad a un momento dado habilitada,
para restaurar tablas se crea un backup del sistema y
eliminadas (p. 1228) se mantiene durante 35 días (sin
costo adicional). Para obtener
más información, consulte
Antes de empezar a usar la
recuperación a un momento
dado.

Actualizaciones ahora Ahora puede suscribirse a la 3 de julio de 2018


disponibles sobre RSS (p. 1228) fuente RSS (en la esquina
superior izquierda de esta
página) para recibir notificaciones
sobre actualizaciones de la Guía
para desarrolladores de Amazon
DynamoDB.

Actualizaciones anteriores
En la siguiente tabla se describen cambios importantes en laGuía para desarrolladores de
DynamoDBantes del 3 de julio de 2018.

Cambio Descripción Fecha de modificación

Ir a compatibilidad con DAX Ahora, puede habilitar el 26 de junio de 2018


rendimiento de lectura en
microsegundos para las tablas
Amazon DynamoDB en sus
aplicaciones escritas en el

Versión de API 2012-08-10


1232
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación


lenguaje de programación Go
utilizando el nuevo SDK de
DynamoDB Accelerator (DAX)
para Go. Para obtener más
información, consulte DAX SDK
for Go (p. 751).

DynamoDB SLA DynamoDB ha lanzado un 19 de junio de 2018


SLA de disponibilidad pública.
Para obtener más información,
consulte el Acuerdo de nivel de
servicios de Amazon DynamoDB.

Backups continuos de y La recuperación a un momento 25 de abril de 2018


recuperación a un momento dado ayuda a proteger las
(PITR) de DynamoDB tablas de Amazon DynamoDB
de operaciones accidentales
de escritura o eliminación.
Al habilitar la recuperación a
un momento dado, ya no hay
que preocuparse por crear,
mantener o planificar backups
bajo demanda. Por ejemplo,
imaginemos que un script de
prueba escribe accidentalmente
en una tabla de DynamoDB. Con
la recuperación a un momento
dado, puede restaurar la tabla
a cualquier momento de los
últimos 35 días. DynamoDB
mantiene backups acumulativos
de la tabla. Para obtener
más información, consulte
Recuperación a un momento
dado para DynamoDB (p. 715).

Cifrado en reposo para El cifrado de DynamoDB 8 de febrero de 2018


DynamoDB en reposo, disponible para
nuevas tablas de DynamoDB,
ayuda a proteger los datos
de aplicaciones en tablas
de Amazon DynamoDB
utilizandoAWSalmacenadas
enAWS Key Management
Service. Para obtener más
información, consulte DynamoDB
ado en reposo (p. 884).

Versión de API 2012-08-10


1233
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Backup y restauración de La función de backup bajo 29 de noviembre de 2017


DynamoDB demanda permite crear backups
completos de los datos de las
tablas de DynamoDB para
archivarlos, lo que le ayuda
a satisfacer los requisitos
reglamentarios corporativos
y gubernamentales. Puede
crear backups 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. Para obtener más
información, consulte Backup
bajo demanda y restauración
para DynamoDB (p. 701).

Tablas globales de DynamoDB Las tablas globales se basan en 29 de noviembre de 2017


la red global de DynamoDB para
proporcionarle una base de datos
completamente administrada en
varias regiones y con múltiples
actividades, que proporciona
un rendimiento rápido de las
operaciones locales de lectura
y escritura para aplicaciones
globales a escala masiva.
Las tablas globales replican
automáticamente las tablas
de Amazon DynamoDB en
su elección deAWSregiones.
Para obtener más información,
consulte Tablas globales:
Replicación en varias regiones
con DynamoDB (p. 370).

Compatibilidad de Node.js para Los desarrolladores de Node.js 5 de octubre de 2017


DAX pueden aprovechar DynamoDB
Accelerator (DAX), utilizando
el cliente DAX para Node.js.
Para obtener más información,
consulte Accelerator en memoria
con DynamoDB Accelerator
(DAX) (p. 722).

Versión de API 2012-08-10


1234
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Puntos de enlace de la VPC para Los puntos de conexión de 16 de agosto de 2017


DynamoDB DynamoDB permiten que las
instancias Amazon EC2 de
Amazon de su VPC accedan
a DynamoDB, sin exponerse
a la infraestructura pública de
Internet. El tráfico de red entre
su VPC y DynamoDB no sale de
la red de Amazon. Para obtener
más información, consulte Uso
de puntos de enlace de Amazon
VPC para obtener acceso a
DynamoDB (p. 927).

Auto Scaling de DynamoDB El escalado automático 14 de junio de 2017


de DynamoDB elimina la
necesidad de definir o ajustar
manualmente los ajustes de
desempeño provisionado.
En su lugar, el escalado
automático de DynamoDB ajusta
dinámicamente la capacidad de
lectura y escritura para responder
a los patrones de tráfico reales.
Esto permite a una tabla o índice
secundario global incrementar su
capacidad de lectura y escritura
aprovisionada para abastecer
incrementos repentinos del
tráfico sin limitaciones. Cuando
la carga de trabajo disminuye,
el escalado automático de
DynamoDB reduce la capacidad
aprovisionada. 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).

DynamoDB Accelerator (DAX) DynamoDB Accelerator (DAX) 19 de abril de 2017


es una caché en memoria
altamente disponible y totalmente
administrada para DynamoDB
que mejora el rendimiento hasta
por diez (de milisegundos a
microsegundos) incluso con
millones de solicitudes por
segundo. Para obtener más
información, consulte Accelerator
en memoria con DynamoDB
Accelerator (DAX) (p. 722).

Versión de API 2012-08-10


1235
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

DynamoDB admite ahora el El tiempo de vida de Amazon 27 de febrero de 2017


vencimiento automático de DynamoDB (TTL) permite
elementos con Timeto Live (TTL) eliminar automáticamente
los elementos de las tablas
que han vencido, sin ningún
costo adicional. Para obtener
más información, consulte
Vencimiento de elementos
mediante el uso de tiempo de
vida (TL) de DynamoDB (p. 446).

DynamoDB admite el etiquetado A partir de ahora, puede agregar 19 de enero de 2017


de asignación de costos etiquetas a las tablas de Amazon
DynamoDB para mejorar el
proceso de categorización
del uso y generar informes
de costos más granulares.
Para obtener más información,
consulte Agregar etiquetas a los
recursos (p. 394).

Nuevo LaDescribeLimitsAPI 1 de marzo de 2016


DynamoDBDescribeLimitsAPI devuelve los límites de capacidad
aprovisionada actuales para
suAWSEn una región, tanto para
la región en su conjunto como
para cualquier tabla concreta de
DynamoDB que se cree en ella.
La API permite determinar cuáles
son los límites actuales en el
nivel de cuenta, para que pueda
compararlos con la capacidad
aprovisionada que está utilizando
y disponga de tiempo suficiente
para solicitar un aumento antes
de agotarla. Para obtener más
información, consulteCuotas
de servicio, cuenta y tabla en
Amazon DynamoDB (p. 1066)y
laDescribeLimitsen laReferencia
de la API de Amazon
DynamoDB.

Versión de API 2012-08-10


1236
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Actualización de la consola de La consola de administración de 12 de noviembre de 2015


DynamoDB y nueva terminología DynamoDB se ha rediseñado
relativa a los atributos de clave para que resulte más intuitiva
principal y fácil de usar. Durante esta
actualización, hemos introducido
una terminología nueva para los
atributos de clave principal:

• Clave de partición,
denominada también atributo
hash.
• Clave de ordenación,
denominada también atributo
de intervalo.

Solo se han modificado los


nombres; la funcionalidad sigue
siendo la misma.

Al crear una tabla o un índice


secundario, puede elegir entre
una clave principal simple (que
solo tiene una clave de partición)
o compuesta (que consta de
clave de partición y clave de
ordenación). La documentación
de DynamoDB se ha actualizado
para reflejar estos cambios.

Versión de API 2012-08-10


1237
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Amazon DynamoDB Storage DynamoDB Storage Backend 20 de agosto de 2015


Backend for Titan for Titan es un paquete de
almacenamiento backend para la
base de datos de gráficos Titan
que se implementa en Amazon
DynamoDB. Cuando se usa
DynamoDB Storage Backend
for Titan, los datos se benefician
de la protección de DynamoDB,
que abarca los centros de
datos de alta disponibilidad
de Amazon. El complemento
está disponible para Titan
versión 0.4.4 (principalmente
con fines de compatibilidad con
las aplicaciones existentes) y
Titan versión 0.5.4 (recomendado
para nuevas aplicaciones). Al
igual que en los demás paquetes
de almacenamiento backend
para Titan, este complemento
es compatible con el stack
Tinkerpop (versiones 2.4 y 2.5),
incluidos la API Blueprints y el
shell Gremlin. Para obtener más
información, consulte Amazon
DynamoDB Storage Backend for
Titan (p. 1135).

Versión de API 2012-08-10


1238
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Streams, replicación entre DynamoDB Streams captura una 16 de julio de 2015


regiones y examen de secuencia en orden cronológico
DynamoDB con lecturas de de las modificaciones de los
consistencia alta elementos en una tabla de
DynamoDB y almacena esta
información en un log durante
un máximo de 24 horas. Las
aplicaciones pueden obtener
acceso a este registro y ver los
elementos de datos tal y como
se encontraban antes y después
de la modificación, prácticamente
en tiempo real. Para obtener más
información, consulteCaptura
de datos de cambio para
DynamoDB Streams (p. 661)y
laReferencia de la API de
DynamoDB Streams.

La replicación entre regiones


de DynamoDB es una solución
del lado del cliente para
mantener copias idénticas
de tablas de DynamoDB en
diferentesAWSregiones de la
región, casi en tiempo real.
Puede utilizar la replicación entre
regiones para realizar backups
de las tablas de DynamoDB o
para proporcionar acceso de
baja latencia a los datos cuando
los usuarios se encuentran
distribuidos geográficamente.

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.

Versión de API 2012-08-10


1239
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

AWS CloudTrailcompatibilidad DynamoDB ahora está integrado 28 de mayo de 2015


con Amazon DynamoDB con CloudTrail. CloudTrail
captura las llamadas al API
realizadas desde la consola
de DynamoDB o desde el
API de DynamoDB y las
registra en archivos log. Para
obtener más información,
consulteRegistro de operaciones
de DynamoDB utilizandoAWS
CloudTrail (p. 964)y laAWS
CloudTrailGuía del usuario.

Compatibilidad mejorada con En esta versión, se agrega 27 de abril de 2015


expresiones de consulta un nuevo parámetro
KeyConditionExpression
al API Query. Una operación
Query lee los elementos
de una tabla o un índice
usando los valores de clave
principal. El parámetro
KeyConditionExpression
es una cadena que identifica
los nombres de las claves
principales y las condiciones
que se deben aplicar a los
valores de claves; Query
recupera solamente aquellos
elementos que satisfacen
la expresión. La sintaxis
deKeyConditionExpressiones
parecida a la de otros
parámetros de expresión
de DynamoDB y permite
definir variables de sustitución
para los nombres y valores
contenidos en la expresión.
Para obtener más información,
consulte Uso de consultas en
DynamoDB (p. 497).

Versión de API 2012-08-10


1240
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Nuevas funciones de En DynamoDB, la 27 de abril de 2015


comparación para escrituras propiedadConditionExpressiondetermina
condicionales si un
parámetroPutItem,UpdateItem,
o bienDeleteItemtiene éxito: El
elemento se escribe únicamente
si la condición se evalúa
como true. En esta versión
se agregan dos funciones
nuevas, attribute_type
y size, para usarlas con
ConditionExpression. Estas
funciones permiten llevar a
cabo escrituras condicionales
según el tipo o de datos o el
tamaño de un atributo de la tabla.
Para obtener más información,
consulte Expresiones de
condición (p. 428).

API Scan para índices En DynamoDB, unScanlee 10 de febrero de 2015


secundarios todos los elementos de una
tabla, aplica criterios de
filtrado definidos por el usuario
y devuelve a la aplicación
los elementos de datos
seleccionados. Esta misma
funcionalidad se encuentra
ahora disponible para los índices
secundarios. Para examinar un
índice secundario local o global,
se especifican los nombres del
índice y de su tabla principal.
De forma predeterminada, la
operación Scan aplicada a un
índice devuelve todos los datos
que este contiene; sin embargo,
puede utilizar una expresión de
filtro para delimitar los resultados
que se devuelven a la aplicación.
Para obtener más información,
consulte Uso de operaciones de
examen en DynamoDB (p. 516).

Versión de API 2012-08-10


1241
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Operaciones online con índices La indexación online permite 27 de enero de 2015


secundarios globales agregar o eliminar índices
secundarios globales de
las tablas existentes. Con
la indexación online, no es
necesario definir todos los
índices de una tabla al crearla,
sino que puede agregar un índice
nuevo en cualquier momento.
Del mismo modo, si decide
que ya no necesita un índice,
puede eliminarlo cuando lo
desee. Las operaciones de
indexación online no aplican
bloqueos, de modo que la tabla
permanece disponible para la
actividad de lectura y escritura
mientras se agregan o eliminan
los índices. Para obtener
más información, consulte
Administración de índices
secundarios globales (p. 579).

Compatibilidad del modelo de DynamoDB permite almacenar y 7 de octubre de 2014


documento con JSON recuperar documentos con plena
compatibilidad con los modelos
de documentos. Los tipos de
datos nuevos son totalmente
compatibles con el estándar
JSON y permiten anidar los
componentes de documentos
unos en otros. Puede utilizar los
operadores de desreferenciación
de rutas de documentos para
leer y escribir componentes
individuales, sin tener que
recuperar todo el documento.
En esta versión también se
incorporan nuevos parámetros
de expresión para especificar
proyecciones, condiciones y
acciones de actualización al leer
o escribir elementos de datos.
Para obtener más información
sobre la compatibilidad de
los modelos de documentos
con JSON, consulte Tipos
de datos (p. 14) y Uso
de expresiones en
DynamoDB (p. 421).

Versión de API 2012-08-10


1242
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Escalado flexible Para las tablas y los índices 7 de octubre de 2014


secundarios globales, puede
aumentar la capacidad de
rendimiento aprovisionado de
lectura y escritura en cualquier
cantidad, siempre y cuando
no rebase los límites de cada
cuenta o tabla. Para obtener más
información, consulte Cuotas
de servicio, cuenta y tabla en
Amazon DynamoDB (p. 1066).

Tamaños de elementos mayores El tamaño máximo de 7 de octubre de 2014


elemento en DynamoDB se ha
aumentado de 64 a 400 KB.
Para obtener más información,
consulte Cuotas de servicio,
cuenta y tabla en Amazon
DynamoDB (p. 1066).

Expresiones condicionales DynamoDB amplía los 24 de abril de 2014


mejoradas operadores que están
disponibles para las expresiones
condicionales, lo que aporta más
flexibilidad en las operaciones
de colocación, actualización y
eliminación condicionales. Los
nuevos operadores disponibles
permiten comprobar si un atributo
existe o no, si es mayor o igual
que un valor determinado, si
está comprendido entre dos
valores o comienza por unos
caracteres en concreto, entre
otras condiciones. DynamoDB
también ofreceORpara evaluar
condiciones múltiples. De forma
predeterminada, se utiliza AND
entre las condiciones de una
expresión, de tal forma que esta
solo será true si lo son todas
las condiciones que contiene.
Si especifica OR en su lugar,
la expresión será true si una
o varias condiciones lo son.
Para obtener más información,
consulte Uso de elementos y
atributos (p. 410).

Versión de API 2012-08-10


1243
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Filtro de consulta El DynamoDBQueryLa API 24 de abril de 2014


admite una nuevaQueryFilter.
De forma predeterminada, la
operación Query busca los
elementos que coinciden con
un determinado valor de clave
de partición y una condición de
clave de ordenación opcional.
Un filtro de Query aplica
expresiones condicionales a
otros atributos sin clave; si hay
un filtro Query presente, los
elementos que no coinciden
con las condiciones del
filtro se descartan antes de
devolver los resultados de
Query a la aplicación. Para
obtener más información,
consulte Uso de consultas en
DynamoDB (p. 497).

Exportación e importación La consola de DynamoDB se 6 de marzo de 2014


de datos mediante laAWS ha mejorado para simplificar la
Management Console exportación e importación de
datos de tablas de DynamoDB.
Con tan solo unos clics, puede
configurar unaAWS Data
PipelinePara organizar el flujo
de trabajo y un clúster de
Amazon Elastic MapReduce
para copiar los datos de las
tablas de DynamoDB en un
bucket de Amazon S3, o
viceversa. Puede realizar la
importación o exportación
una sola vez o configurar
un trabajo de exportación
diario. Incluso puede realizar
importaciones y exportaciones
entre regiones copiando los
datos de DynamoDB de una
tabla en unaAWSregión a
una tabla en otraAWSregion.
Para obtener más información,
consulte Importación y
exportación de datos de
DynamoDB medianteAWS Data
Pipeline (p. 1125).

Versión de API 2012-08-10


1244
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Reorganización de la Ahora resulta más fácil encontrar 20 de enero de 2014


documentación de la API de nivel información sobre las API
superior siguientes:

• Java: DynamoDBMappper
• .NET: Modelo de documento
y modelo de persistencia de
objetos

Estas API de nivel superior se


documentan aquí: Interfaces de
programación de nivel superior
para DynamoDB (p. 230).

Índices secundarios globales DynamoDB incorpora 12 de diciembre de 2013


compatibilidad con los índices
secundarios globales. Al igual
que sucede con un índice
secundario local, un índice
secundario global se define
mediante una clave alternativa
de una tabla y, a continuación,
se emiten solicitudes Query para
consultarlo. A diferencia de un
índice secundario local, la clave
de partición del índice secundario
global no tiene que ser la
misma que la clave de partición
de la tabla, sino que puede
ser cualquier atributo escalar
de esta última. La clave de
ordenación es opcional y también
puede ser cualquier atributo
escalar de la tabla. Además,
un índice secundario global
presenta sus propios ajustes de
rendimiento aprovisionado, que
son independientes de los de su
tabla principal. Para obtener más
información, consulte Uso de
índices secundarios para mejorar
el acceso a los datos (p. 567) y
Uso de índices secundarios en
DynamoDB (p. 570).

Versión de API 2012-08-10


1245
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Control de acceso preciso DynamoDB incorpora 29 de octubre de 2013


compatibilidad con el control
de acceso preciso. Esta
característica permite a los
clientes especificar qué
entidades principales (usuarios,
grupos o roles) pueden obtener
acceso a los elementos y
atributos individuales de una
tabla o un índice secundario de
DynamoDB. Las aplicaciones
también pueden sacar partido de
las identidades web federadas
para delegar la tarea de
autenticar a los usuarios en
un proveedor de identidades
tercero, como Facebook, Google
o Login with Amazon. De esta
forma, las aplicaciones (incluidas
las aplicaciones para móviles)
pueden administrar grandes
cantidades de usuarios y, al
mismo tiempo, asegurarse
de que nadie pueda obtener
acceso a los elementos de datos
de DynamoDB a menos que
estén autorizados para ello.
Para obtener más información,
consulte Uso de condiciones de
políticas de IAM para control de
acceso preciso (p. 909).

Unidades de capacidad de El tamaño de la unidad de 14 de mayo de 2013


lectura de 4 KB capacidad de lectura ha
aumentado de 1 a 4 KB. Esta
mejora permite reducir el número
de unidades de capacidad de
lectura aprovisionadas que
se requieren para muchas
aplicaciones. Por ejemplo,
antes de esta versión, para
leer un elemento de 10 KB se
consumían 10 unidades de
capacidad de lectura; ahora,
la misma lectura de 10 KB
solo consumiría 3 unidades
(10 KB/4 KB, redondeados al
múltiplo de 4 KB inmediatamente
superior). Para obtener más
información, consulte Modo
de capacidad de lectura/
escritura (p. 18).

Versión de API 2012-08-10


1246
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Exámenes en paralelo DynamoDB incorpora 14 de mayo de 2013


compatibilidad con las
operaciones Scan en paralelo.
Ahora, las aplicaciones pueden
dividir una tabla en segmentos
lógicos y examinar todos
ellos simultáneamente. Esta
característica reduce el tiempo
necesario para que se complete
una operación Scan y utiliza
plenamente la capacidad de
lectura aprovisionada de la tabla.
Para obtener más información,
consulte Uso de operaciones de
examen en DynamoDB (p. 516).

Índices secundarios locales DynamoDB incorpora 18 de abril de 2013


compatibilidad con los índices
secundarios locales. Se pueden
definir índices de clave de
ordenación basados en atributos
sin clave y, a continuación,
utilizarlos en solicitudes Query.
Con los índices secundarios
locales, las aplicaciones pueden
recuperar de manera eficiente
elementos de datos que abarcan
varias dimensiones. Para
obtener más información,
consulte Índices secundarios
locales (p. 612).

Nueva versión de la API En esta versión, DynamoDB 18 de abril de 2013


introduce una nueva versión
del API (2012-08-10). La
versión de la API anterior
(2011-12-05) se admite todavía
con fines de compatibilidad
retroactiva con las aplicaciones
existentes. Las nuevas
aplicaciones deben utilizar
la nueva versión de la API,
2012-08-10. Recomendamos
migrar las aplicaciones existentes
a la versión 2012-08-10
del API, porque las nuevas
características de DynamoDB
(como los índices secundarios
locales) no se podrán aplicar
retroactivamente en la versión
anterior del API. Para obtener
más información acerca del API
versión 2012-08-10, consulte
laReferencia de la API de
Amazon DynamoDB.

Versión de API 2012-08-10


1247
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Compatibilidad con variables de El lenguaje de la política de 4 de abril de 2013


políticas de IAM acceso de IAM ya es compatible
con variables. Cuando se evalúa
una política, las variables de la
política se sustituyen por valores
facilitados por información
basada en contexto desde la
sesión del usuario autenticado.
Puede utilizar las variables de
políticas para definir políticas con
un propósito general sin mostrar
un listado explícito con todos
los componentes de la política.
Para obtener más información
acerca de las variables de las
políticas, consulteVariables de
las políticasen laAWS Identity
and Access ManagementUso de
IAMguía.

Para obtener algunos ejemplos


de variables de políticas de
DynamoDB, consulteIdentity and
Access Management (p. 894).

Ejemplos de código PHP En la versión 2 delAWS SDK 23 de enero de 2013


actualizados paraAWS SDK for for PHPya está disponible. Los
PHPVersión 2 ejemplos de código PHP de la
Guía para desarrolladores de
Amazon DynamoDB se han
actualizado para utilizar este
nuevo SDK. Para obtener más
información acerca de la versión
2 del SDK, consulteAWS SDK for
PHP.

Nuevo punto de enlace de El DynamoDB se expande 3 de diciembre de 2012


alAWSRegión GovCloud (EE.UU.
Oeste). Para obtener la lista
actualizada de puntos de enlace
de servicio y protocolos, consulte
Regiones y puntos de enlace de
AWS.

Nuevo punto de enlace de DynamoDB se expande a la 3 de diciembre de 2012


región de Sudamérica (São
Paulo). Para obtener la lista
actualizada de puntos de enlace
admitidos, consulte Regiones y
puntos de enlace de AWS.

Versión de API 2012-08-10


1248
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Nuevo punto de enlace de DynamoDB se expande a la 13 de noviembre de 2012


región Asia-Pacífico (Sídney).
Para obtener la lista actualizada
de puntos de enlace admitidos,
consulte Regiones y puntos de
enlace de AWS.

DynamoDB implementa la • DynamoDB calcula una 2 de noviembre de 2012


compatibilidad con las sumas de suma de comprobación
comprobación CRC32, admite CRC32 de la carga de HTTP y
las operaciones de obtención devuelve su valor en un nuevo
por lotes de consistencia alta y encabezado,x-amz-crc32.
elimina las restricciones a las Para obtener más información,
actualizaciones simultáneas de consulte API de bajo nivel de
tablas. DynamoDB (p. 220).
• De forma predeterminada,
las operaciones de lectura
realizadas mediante la
API BatchGetItem son
consistentes finales. Un nuevo
parámetro ConsistentRead
de BatchGetItem permite
elegir lecturas de consistencia
alta en su lugar para las tablas
incluidas en la solicitud. Para
obtener más información,
consulte Description (p. 1162).
• En esta versión se eliminan
algunas restricciones que se
aplicaban a la actualización
simultánea de varias tablas.
El número total de tablas
que se pueden actualizar
a la vez sigue siendo 10;
sin embargo, ahora pueden
encontrarse en cualquier
combinación de estados
CREATING, UPDATING o
DELETING. Tampoco se aplica
ya ninguna cantidad mínima
para aumentar o reducir los
valores de ReadCapacityUnits
o WriteCapacityUnits de
una tabla. Para obtener más
información, consulte Cuotas
de servicio, cuenta y tabla en
Amazon DynamoDB (p. 1066).

Versión de API 2012-08-10


1249
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Documentación de prácticas En la Guía para desarrolladores 28 de septiembre de 2012


recomendadas de Amazon DynamoDB
se identifican las prácticas
recomendadas para usar
tablas y elementos, así como
recomendaciones sobre las
operaciones de consulta y
examen.

Versión de API 2012-08-10


1250
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Compatibilidad con el tipo de Además de los tipos Number 21 de agosto de 2012


datos Binary y String, a partir de ahora
DynamoDB admite el tipo de
datos Binary.

Antes de esta versión, para


almacenar datos binarios
había que convertirlos en
cadenas antes de almacenarlos
en DynamoDB. Además del
trabajo de conversión en el
lado del cliente, este proceso
solía aumentar el tamaño del
elemento de datos, con lo que
se requería más espacio de
almacenamiento y, posiblemente,
mayor capacidad de rendimiento
aprovisionada.

Ahora, los atributos de tipo


Binary permiten almacenar
datos binarios de cualquier
índole, tales como datos
comprimidos, datos cifrados o
imágenes. Para obtener más
información, consulte Tipos
de datos (p. 14). Para obtener
ejemplos funcionales de cómo
utilizar datos de tipo Binary
en laAWSPara obtener los
SDK, consulte las siguientes
secciones:

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

Para el soporte de tipo de


datos binarios agregado en
elAWSNecesita descargar
los SDK más recientes y
puede que también tenga que
actualizar las aplicaciones
existentes. Para obtener más
información acerca de la
descarga deAWSLos Software
Development KitEjemplos de
código .NET (p. 340).

Versión de API 2012-08-10


1251
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Los elementos de las tablas de Además de agregar y eliminar 14 de agosto de 2012


DynamoDB se pueden actualizar elementos de tablas, ahora
y copiar desde la consola de usuarios de DynamoDB también
DynamoDB pueden actualizarlos y copiarlos
desde la consola de DynamoDB.
Esta nueva funcionalidad
simplifica la modificación de
elementos individuales en la
consola.

DynamoDB reduce los requisitos DynamoDB ahora admite 9 de agosto de 2012


mínimos de desempeño por tabla requisitos más bajos de
desempeño de cada tabla; en
concreto, 1 unidad de capacidad
de escritura y 1 unidad de
capacidad de lectura. Para
obtener más información,
consulte laCuotas de servicio,
cuenta y tabla en Amazon
DynamoDB (p. 1066)en la Guía
para desarrolladores de Amazon
DynamoDB.

Compatibilidad con Signature DynamoDB ahora es compatible 5 de julio de 2012


Version 4 con Signature Version 4 para
autenticar solicitudes.

Compatibilidad con el explorador La consola de DynamoDB ya es 22 de mayo de 2012


de tablas en DynamoDB compatible con un explorador de
tablas que permite consultar y
examinar los datos contenidos
en ellas. También puede insertar
nuevos elementos o eliminar
los existentes. Las secciones
Creación de tablas y carga
de datos para ejemplos de
código en DynamoDB (p. 333)
y Mediante la consola (p. 60) se
han actualizado para incluir estas
nuevas características.

Nuevos puntos de enlace La disponibilidad de DynamoDB 24 de abril de 2012


se expande con nuevos puntos
finales en la región EE.UU.
Oeste (Norte de California), la
región EE.UU. Oeste (Oregón)
y la región de Asia Pacífico
(Singapur).

Para obtener la lista actualizada


de puntos de enlace admitidos,
visite Regiones y puntos de
enlace.

Versión de API 2012-08-10


1252
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Compatibilidad con la API DynamoDB ahora es compatible 19 de abril de 2012


BatchWriteItem con una API de escritura por
lotes que permite colocar y
eliminar varios elementos de
una o varias tablas en una
única llamada al API. Para
obtener más información
acerca de la API de escritura
por lotes de DynamoDB,
consulteBatchWriteItem (p. 1167).

Para obtener más información


sobre cómo usar elementos
y aplicar la característica de
escritura por lotes enAWSLos
Software Development
KitUso de elementos y
atributos (p. 410)yEjemplos de
código .NET (p. 340).

Más códigos de error Para obtener más información, 5 de abril de 2012


documentados consulte Control de errores con
DynamoDB (p. 224).

Nuevo punto de enlace de DynamoDB se expande a la 29 de febrero de 2012


región Asia-Pacífico (Tokio).
Para obtener la lista actualizada
de puntos de enlace admitidos,
consulte Regiones y puntos de
enlace de AWS.

Se agrega la métrica Una nueva 24 de febrero de 2012


ReturnedItemCount métrica,ReturnedItemCount,
proporciona el número de
elementos devueltos en la
respuesta a una operación Query
o Scan para DynamoDB está
disponible para monitorizarla
en CloudWatch. Para obtener
más información, consulte
Registro y monitorización en
DynamoDB (p. 938).

Se agregan ejemplos sobre el DynamoDB permite incrementar 25 de enero de 2012


incremento de valores y disminuir los valores numéricos
existentes. Se incluyen ejemplos
de cómo agregar valores a otros
existentes en los apartados
"Actualización de un elemento"
de las secciones:

Uso de elementos: Java (p. 453).

Uso de elementos: .NET (p. 474).

Versión de API 2012-08-10


1253
Amazon DynamoDB Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha de modificación

Lanzamiento del producto inicial Se presenta la versión Beta de 18 de enero de 2012


DynamoDB como nuevo servicio.

Versión de API 2012-08-10


1254
Amazon DynamoDB Guía para desarrolladores

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.

Versión de API 2012-08-10


mcclv

También podría gustarte