DynamoDB - Guide rapide

DynamoDB permet aux utilisateurs de créer des bases de données capables de stocker et de récupérer n'importe quelle quantité de données, et de desservir n'importe quelle quantité de trafic. Il distribue automatiquement les données et le trafic sur les serveurs pour gérer dynamiquement les demandes de chaque client et maintient également des performances rapides.

DynamoDB contre SGBDR

DynamoDB utilise un modèle NoSQL, ce qui signifie qu'il utilise un système non relationnel. Le tableau suivant met en évidence les différences entre DynamoDB et RDBMS -

Tâches communes	SGBDR	DynamoDB
Connect to the Source	Il utilise une connexion persistante et des commandes SQL.	Il utilise des requêtes HTTP et des opérations API
Create a Table	Ses structures fondamentales sont des tables et doivent être définies.	Il n'utilise que des clés primaires et aucun schéma lors de la création. Il utilise diverses sources de données.
Get Table Info	Toutes les informations de la table restent accessibles	Seules les clés primaires sont révélées.
Load Table Data	Il utilise des lignes constituées de colonnes.	Dans les tableaux, il utilise des éléments composés d'attributs
Read Table Data	Il utilise des instructions SELECT et des instructions de filtrage.	Il utilise GetItem, Query et Scan.
Manage Indexes	Il utilise des index standard créés via des instructions SQL. Les modifications y sont apportées automatiquement lors des changements de table.	Il utilise un index secondaire pour réaliser la même fonction. Il nécessite des spécifications (clé de partition et clé de tri).
Modify Table Data	Il utilise une instruction UPDATE.	Il utilise une opération UpdateItem.
Delete Table Data	Il utilise une instruction DELETE.	Il utilise une opération DeleteItem.
Delete a Table	Il utilise une instruction DROP TABLE.	Il utilise une opération DeleteTable.

Avantages

Les deux principaux avantages de DynamoDB sont l'évolutivité et la flexibilité. Il ne force pas l'utilisation d'une source de données et d'une structure particulières, permettant aux utilisateurs de travailler avec pratiquement n'importe quoi, mais de manière uniforme.

Sa conception prend également en charge un large éventail d'utilisations, des tâches et opérations plus légères aux fonctionnalités d'entreprise exigeantes. Il permet également une utilisation simple de plusieurs langages: Ruby, Java, Python, C #, Erlang, PHP et Perl.

Limites

DynamoDB souffre de certaines limitations, cependant, ces limitations ne créent pas nécessairement d'énormes problèmes ou n'entravent pas un développement solide.

Vous pouvez les revoir à partir des points suivants -

Capacity Unit Sizes- Une unité de capacité de lecture est une seule lecture cohérente par seconde pour les éléments ne dépassant pas 4 Ko. Une unité de capacité d'écriture est une seule écriture par seconde pour les éléments ne dépassant pas 1 Ko.
Provisioned Throughput Min/Max- Toutes les tables et tous les index secondaires globaux ont au minimum une unité de capacité de lecture et une unité de capacité d'écriture. Les maximums dépendent de la région. Aux États-Unis, 40K en lecture et en écriture restent le plafond par table (80K par compte), et d'autres régions ont un plafond de 10K par table avec un plafond de 20K de compte.
Provisioned Throughput Increase and Decrease - Vous pouvez l'augmenter aussi souvent que nécessaire, mais les diminutions restent limitées à pas plus de quatre fois par jour par table.
Table Size and Quantity Per Account - Les tailles de table n'ont pas de limites, mais les comptes ont une limite de 256 tables, sauf si vous demandez un plafond plus élevé.
Secondary Indexes Per Table - Cinq locaux et cinq mondiaux sont autorisés.
Projected Secondary Index Attributes Per Table - DynamoDB autorise 20 attributs.
Partition Key Length and Values - Leur longueur minimale est de 1 octet et maximale de 2048 octets, cependant, DynamoDB ne place aucune limite sur les valeurs.
Sort Key Length and Values - Sa longueur minimale est de 1 octet, et maximale de 1024 octets, sans limite de valeurs sauf si sa table utilise un index secondaire local.
Table and Secondary Index Names - Les noms doivent comporter au minimum 3 caractères et au maximum 255. Ils utilisent les caractères suivants: AZ, az, 0-9, «_», «-» et «.».
Attribute Names - Un caractère reste le minimum et 64 Ko le maximum, avec des exceptions pour les clés et certains attributs.
Reserved Words - DynamoDB n'empêche pas l'utilisation de mots réservés comme noms.
Expression Length- Les chaînes d'expression ont une limite de 4 Ko. Les expressions d'attributs ont une limite de 255 octets. Les variables de substitution d'une expression ont une limite de 2 Mo.

Avant d'utiliser DynamoDB, vous devez vous familiariser avec ses composants de base et son écosystème. Dans l'écosystème DynamoDB, vous travaillez avec des tables, des attributs et des éléments. Une table contient des ensembles d'éléments et les éléments contiennent des ensembles d'attributs. Un attribut est un élément fondamental de données ne nécessitant aucune décomposition supplémentaire, c'est-à-dire un champ.

Clé primaire

Les clés primaires servent de moyen d'identification unique pour les éléments de table et les index secondaires offrent une flexibilité de requête. Les flux DynamoDB enregistrent les événements en modifiant les données de la table.

La création de table nécessite non seulement de définir un nom, mais également la clé primaire; qui identifie les éléments du tableau. Aucun élément ne partage une clé. DynamoDB utilise deux types de clés primaires -

Partition Key- Cette clé primaire simple consiste en un seul attribut appelé «clé de partition». En interne, DynamoDB utilise la valeur de clé comme entrée pour une fonction de hachage pour déterminer le stockage.
Partition Key and Sort Key - Cette clé, connue sous le nom de «Clé primaire composite», se compose de deux attributs.
- La clé de partition et
- La clé de tri.
DynamoDB applique le premier attribut à une fonction de hachage et stocke les éléments avec la même clé de partition ensemble; avec leur ordre déterminé par la clé de tri. Les éléments peuvent partager des clés de partition, mais pas les clés de tri.

Les attributs de clé primaire n'autorisent que des valeurs scalaires (uniques); et les types de données chaîne, nombre ou binaire. Les attributs non clés n'ont pas ces contraintes.

Index secondaires

Ces index vous permettent d'interroger les données de la table avec une clé alternative. Bien que DynamoDB ne force pas leur utilisation, ils optimisent les requêtes.

DynamoDB utilise deux types d'index secondaires -

Global Secondary Index - Cet index possède des clés de partition et de tri, qui peuvent différer des clés de table.
Local Secondary Index - Cet index possède une clé de partition identique à la table, cependant, sa clé de tri diffère.

API

Les opérations d'API proposées par DynamoDB incluent celles du plan de contrôle, du plan de données (par exemple, création, lecture, mise à jour et suppression) et des flux. Dans les opérations du plan de contrôle, vous créez et gérez des tables avec les outils suivants:

CreateTable
DescribeTable
ListTables
UpdateTable
DeleteTable

Dans le plan de données, vous effectuez des opérations CRUD avec les outils suivants:

Créer	Lis	Mettre à jour	Effacer
PutItem BatchWriteItem	Obtenir l'article BatchGetItem Requete Analyse	UpdateItem	Effacer l'article BatchWriteItem

Les flux de la table de contrôle des opérations de flux. Vous pouvez consulter les outils de flux suivants -

ListStreams
DescribeStream
GetShardIterator
GetRecords

Débit provisionné

Lors de la création de table, vous spécifiez le débit provisionné, qui réserve des ressources pour les lectures et les écritures. Vous utilisez des unités de capacité pour mesurer et définir le débit.

Lorsque les applications dépassent le débit défini, les demandes échouent. La console GUI DynamoDB permet de surveiller le débit défini et utilisé pour un provisionnement amélioré et dynamique.

Lire la cohérence

Utilise DynamoDB eventually consistent et strongly consistentlit pour prendre en charge les besoins des applications dynamiques. Les lectures finalement cohérentes ne fournissent pas toujours les données actuelles.

Les lectures fortement cohérentes fournissent toujours des données actuelles (à l'exception des pannes d'équipement ou des problèmes de réseau). Les lectures finalement cohérentes servent de paramètre par défaut, nécessitant un paramètre true dans leConsistentRead paramètre pour le changer.

Partitions

DynamoDB utilise des partitions pour le stockage des données. Ces allocations de stockage pour les tables ont un support SSD et se répliquent automatiquement entre les zones. DynamoDB gère toutes les tâches de partition, ne nécessitant aucune intervention de l'utilisateur.

Lors de la création de table, la table entre dans l'état CREATING, qui alloue des partitions. Lorsqu'il atteint l'état ACTIF, vous pouvez effectuer des opérations. Le système modifie les partitions lorsque sa capacité atteint son maximum ou lorsque vous modifiez le débit.

L'environnement DynamoDB consiste uniquement à utiliser votre compte Amazon Web Services pour accéder à la console d'interface graphique DynamoDB, mais vous pouvez également effectuer une installation locale.

Accédez au site Web suivant - https://aws.amazon.com/dynamodb/

Cliquez sur le bouton «Premiers pas avec Amazon DynamoDB» ou sur le bouton «Créer un compte AWS» si vous ne possédez pas de compte Amazon Web Services. Le processus simple et guidé vous informera de tous les frais et exigences associés.

Après avoir effectué toutes les étapes nécessaires du processus, vous aurez accès. Connectez-vous simplement à la console AWS, puis accédez à la console DynamoDB.

Assurez-vous de supprimer le matériel inutilisé ou inutile pour éviter les frais associés.

Installation locale

AWS (Amazon Web Service) fournit une version de DynamoDB pour les installations locales. Il prend en charge la création d'applications sans service Web ni connexion. Il réduit également le débit provisionné, le stockage des données et les frais de transfert en autorisant une base de données locale. Ce guide suppose une installation locale.

Lorsque vous êtes prêt pour le déploiement, vous pouvez apporter quelques petits ajustements à votre application pour la convertir en utilisation AWS.

Le fichier d'installation est un .jar executable. Il fonctionne sous Linux, Unix, Windows et tout autre système d'exploitation prenant en charge Java. Téléchargez le fichier en utilisant l'un des liens suivants -

Tarball - http://dynamodb-local.s3-website-us-west2.amazonaws.com/dynamodb_local_latest.tar.gz
Zip archive - http://dynamodb-local.s3-website-us-west2.amazonaws.com/dynamodb_local_latest.zip

Note- D'autres référentiels proposent le fichier, mais pas nécessairement la dernière version. Utilisez les liens ci-dessus pour les fichiers d'installation à jour. Assurez-vous également que vous disposez de la version 6.x de Java Runtime Engine (JRE) ou d'une version plus récente. DynamoDB ne peut pas fonctionner avec des versions plus anciennes.

Après avoir téléchargé l'archive appropriée, extrayez son répertoire (DynamoDBLocal.jar) et placez-le à l'emplacement souhaité.

Vous pouvez ensuite démarrer DynamoDB en ouvrant une invite de commande, en accédant au répertoire contenant DynamoDBLocal.jar et en entrant la commande suivante -

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

Vous pouvez également arrêter le DynamoDB en fermant l'invite de commande utilisée pour le démarrer.

Environnement de travail

Vous pouvez utiliser un shell JavaScript, une console GUI et plusieurs langues pour travailler avec DynamoDB. Les langages disponibles incluent Ruby, Java, Python, C #, Erlang, PHP et Perl.

Dans ce didacticiel, nous utilisons des exemples de console Java et GUI pour la clarté conceptuelle et du code. Installez un IDE Java, le SDK AWS pour Java et configurez les informations d'identification de sécurité AWS pour le SDK Java afin d'utiliser Java.

Conversion du code de service local en code de service Web

Lorsque vous êtes prêt pour le déploiement, vous devrez modifier votre code. Les ajustements dépendent du langage du code et d'autres facteurs. Le principal changement consiste simplement à changer leendpointd'un point local à une région AWS. D'autres changements nécessitent une analyse plus approfondie de votre application.

Une installation locale diffère du service Web à bien des égards, y compris, mais sans s'y limiter, les principales différences suivantes:

L'installation locale crée des tables immédiatement, mais le service prend beaucoup plus de temps.
L'installation locale ignore le débit.
La suppression se produit immédiatement dans une installation locale.
Les lectures / écritures se produisent rapidement dans les installations locales en raison de l'absence de surcharge du réseau.

DynamoDB fournit trois options pour effectuer des opérations: une console GUI Web, un shell JavaScript et un langage de programmation de votre choix.

Dans ce didacticiel, nous nous concentrerons sur l'utilisation de la console GUI et du langage Java pour plus de clarté et de compréhension conceptuelle.

Console GUI

La console GUI ou AWS Management Console pour Amazon DynamoDB se trouvent à l'adresse suivante - https://console.aws.amazon.com/dynamodb/home

Il vous permet d'effectuer les tâches suivantes -

CRUD
Afficher les éléments de table
Effectuer des requêtes de table
Définir des alarmes pour la surveillance de la capacité de la table
Afficher les métriques de table en temps réel
Afficher les alarmes du tableau

Si votre compte DynamoDB n'a pas de tables, lors de l'accès, il vous guide tout au long de la création d'une table. Son écran principal propose trois raccourcis pour effectuer des opérations courantes -

Créer des tableaux
Ajouter et interroger des tables
Surveiller et gérer les tables

Le shell JavaScript

DynamoDB comprend un shell JavaScript interactif. Le shell s'exécute dans un navigateur Web et les navigateurs recommandés incluent Firefox et Chrome.

Note - L'utilisation d'autres navigateurs peut entraîner des erreurs.

Accédez au shell en ouvrant un navigateur Web et en saisissant l'adresse suivante -http://localhost:8000/shell

Utilisez le shell en saisissant JavaScript dans le volet gauche, puis en cliquant sur le bouton icône «Lecture» dans le coin supérieur droit du volet gauche, qui exécute le code. Les résultats du code s'affichent dans le volet droit.

DynamoDB et Java

Utilisez Java avec DynamoDB en utilisant votre environnement de développement Java. Les opérations confirment la syntaxe et la structure Java normales.

Les types de données pris en charge par DynamoDB incluent ceux spécifiques aux attributs, aux actions et au langage de codage de votre choix.

Types de données d'attribut

DynamoDB prend en charge un grand ensemble de types de données pour les attributs de table. Chaque type de données appartient à l'une des trois catégories suivantes -

Scalar - Ces types représentent une valeur unique et incluent un nombre, une chaîne, un binaire, un booléen et une valeur nulle.
Document - Ces types représentent une structure complexe possédant des attributs imbriqués et incluent des listes et des cartes.
Set - Ces types représentent plusieurs scalaires et incluent des ensembles de chaînes, des ensembles de nombres et des ensembles binaires.

N'oubliez pas DynamoDB comme une base de données NoSQL sans schéma qui n'a pas besoin de définitions d'attribut ou de type de données lors de la création d'une table. Il ne nécessite que des types de données d'attribut de clé primaire contrairement au SGBDR, qui nécessite des types de données de colonne lors de la création de table.

Scalaires

Numbers - Ils sont limités à 38 chiffres et sont soit positifs, négatifs ou nuls.
String - Ils sont Unicode utilisant UTF-8, avec une longueur minimum de> 0 et maximum de 400 Ko.
Binary- Ils stockent toutes les données binaires, par exemple, des données cryptées, des images et du texte compressé. DynamoDB considère ses octets comme non signés.
Boolean - Ils stockent vrai ou faux.
Null - Ils représentent un état inconnu ou non défini.

Document

List - Il stocke les collections de valeurs ordonnées et utilise des crochets [...] carrés.
Map - Il stocke des collections de paires nom-valeur non ordonnées et utilise des accolades ({...}).

Ensemble

Les ensembles doivent contenir des éléments du même type, qu'il soit numérique, chaîne ou binaire. Les seules limites placées sur les ensembles consistent en la limite de taille d'élément de 400 Ko, et chaque élément étant unique.

Types de données d'action

L'API DynamoDB contient divers types de données utilisés par les actions. Vous pouvez consulter une sélection des types de clés suivants -

AttributeDefinition - Il représente la table de clés et le schéma d'index.
Capacity - Il représente la quantité de débit consommée par une table ou un index.
CreateGlobalSecondaryIndexAction - Il représente un nouvel index secondaire global ajouté à une table.
LocalSecondaryIndex - Il représente les propriétés d'index secondaire local.
ProvisionedThroughput - Il représente le débit provisionné pour un index ou une table.
PutRequest - Il représente les requêtes PutItem.
TableDescription - Il représente les propriétés de la table.

Types de données Java pris en charge

DynamoDB prend en charge les types de données primitifs, les collections Set et les types arbitraires pour Java.

La création d'une table consiste généralement à générer la table, à la nommer, à établir ses attributs de clé primaire et à définir les types de données d'attribut.

Utilisez la console GUI, Java ou une autre option pour effectuer ces tâches.

Créer une table à l'aide de la console GUI

Créez une table en accédant à la console à l'adresse https://console.aws.amazon.com/dynamodb. Choisissez ensuite l'option «Créer une table».

Notre exemple génère un tableau rempli d'informations sur les produits, avec des produits d'attributs uniques identifiés par un numéro d'identification (attribut numérique). dans leCreate Tableécran, entrez le nom de la table dans le champ du nom de la table; entrez la clé primaire (ID) dans le champ de clé de partition; et entrez «Numéro» pour le type de données.

Après avoir entré toutes les informations, sélectionnez Create.

Créer une table à l'aide de Java

Utilisez Java pour créer la même table. Sa clé primaire se compose des deux attributs suivants -

ID - Utilisez une clé de partition et le ScalarAttributeType N, ce qui signifie nombre.
Nomenclature - Utilisez une clé de tri et le ScalarAttributeType S, ce qui signifie chaîne.

Java utilise le createTable methodpour générer une table; et dans l'appel, le nom de la table, les attributs de clé primaire et les types de données d'attribut sont spécifiés.

Vous pouvez consulter l'exemple suivant -

import java.util.Arrays;
 
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient; 
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 ProductsCreateTable {  
   public static void main(String[] args) throws Exception { 
      AmazonDynamoDBClient client = new AmazonDynamoDBClient() 
         .withEndpoint("http://localhost:8000");  
      
      DynamoDB dynamoDB = new DynamoDB(client); 
      String tableName = "Products";  
      try { 
         System.out.println("Creating the table, wait..."); 
         Table table = dynamoDB.createTable (tableName, 
            Arrays.asList ( 
               new KeySchemaElement("ID", KeyType.HASH), // the partition key 
                                                         // the sort key 
               new KeySchemaElement("Nomenclature", KeyType.RANGE)
            ),
            Arrays.asList ( 
               new AttributeDefinition("ID", ScalarAttributeType.N), 
               new AttributeDefinition("Nomenclature", ScalarAttributeType.S)
            ),
            new ProvisionedThroughput(10L, 10L)
         );
         table.waitForActive(); 
         System.out.println("Table created successfully.  Status: " + 
            table.getDescription().getTableStatus());
            
      } catch (Exception e) {
         System.err.println("Cannot create the table: "); 
         System.err.println(e.getMessage()); 
      } 
   } 
}

Dans l'exemple ci-dessus, notez le point de terminaison: .withEndpoint.

Il indique l'utilisation d'une installation locale à l'aide de l'hôte local. Notez également lesProvisionedThroughput parameter, que l'installation locale ignore.

Le chargement d'une table consiste généralement à créer un fichier source, à s'assurer que le fichier source est conforme à une syntaxe compatible avec DynamoDB, à envoyer le fichier source à la destination, puis à confirmer un remplissage réussi.

Utilisez la console GUI, Java ou une autre option pour effectuer la tâche.

Charger la table à l'aide de la console GUI

Chargez les données à l'aide d'une combinaison de la ligne de commande et de la console. Vous pouvez charger des données de plusieurs manières, dont certaines sont les suivantes -

La console
La ligne de commande
Code et aussi
Pipeline de données (une fonctionnalité abordée plus loin dans le didacticiel)

Cependant, pour la vitesse, cet exemple utilise à la fois le shell et la console. Tout d'abord, chargez les données source dans la destination avec la syntaxe suivante -

aws dynamodb batch-write-item -–request-items file://[filename]

Par exemple -

aws dynamodb batch-write-item -–request-items file://MyProductData.json

Vérifiez le succès de l'opération en accédant à la console à -

https://console.aws.amazon.com/dynamodb

Choisir Tables dans le volet de navigation et sélectionnez la table de destination dans la liste des tables.

Sélectionnez le Itemsonglet pour examiner les données que vous avez utilisées pour remplir le tableau. SélectionnerCancel pour revenir à la liste des tableaux.

Charger la table à l'aide de Java

Utilisez Java en créant d'abord un fichier source. Notre fichier source utilise le format JSON. Chaque produit a deux attributs de clé primaire (ID et Nomenclature) et une carte JSON (Stat) -

[ 
   { 
      "ID" : ... , 
      "Nomenclature" : ... , 
      "Stat" : { ... }
   }, 
   { 
      "ID" : ... , 
      "Nomenclature" : ... , 
      "Stat" : { ... } 
   }, 
    ... 
]

Vous pouvez consulter l'exemple suivant -

{ 
   "ID" : 122, 
   "Nomenclature" : "Particle Blaster 5000", 
   "Stat" : { 
      "Manufacturer" : "XYZ Inc.", 
      "sales" : "1M+", 
      "quantity" : 500, 
      "img_src" : "http://www.xyz.com/manuals/particleblaster5000.jpg", 
      "description" : "A laser cutter used in plastic manufacturing." 
   } 
}

L'étape suivante consiste à placer le fichier dans le répertoire utilisé par votre application.

Java utilise principalement le putItem et path methods pour effectuer le chargement.

Vous pouvez consulter l'exemple de code suivant pour traiter un fichier et le charger -

import java.io.File;
import java.util.Iterator;

import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
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 ProductsLoadData {  
   public static void main(String[] args) throws Exception {  
      AmazonDynamoDBClient client = new AmazonDynamoDBClient() 
         .withEndpoint("http://localhost:8000");  
      
      DynamoDB dynamoDB = new DynamoDB(client);  
      Table table = dynamoDB.getTable("Products");  
      JsonParser parser = new JsonFactory() 
         .createParser(new File("productinfo.json"));  
      
      JsonNode rootNode = new ObjectMapper().readTree(parser); 
      Iterator<JsonNode> iter = rootNode.iterator();  
      ObjectNode currentNode;  
      
      while (iter.hasNext()) { 
         currentNode = (ObjectNode) iter.next();  
         int ID = currentNode.path("ID").asInt(); 
         String Nomenclature = currentNode.path("Nomenclature").asText();  
         
         try { 
            table.putItem(new Item() 
               .withPrimaryKey("ID", ID, "Nomenclature", Nomenclature) 
               .withJSON("Stat", currentNode.path("Stat").toString()));
            System.out.println("Successful load: " + ID + " " + Nomenclature);  
         } catch (Exception e) {
            System.err.println("Cannot add product: " + ID + " " + Nomenclature);
            System.err.println(e.getMessage()); 
            break; 
         } 
      } 
      parser.close(); 
   } 
}

L'interrogation d'une table nécessite principalement la sélection d'une table, la spécification d'une clé de partition et l'exécution de la requête; avec la possibilité d'utiliser des index secondaires et d'effectuer un filtrage plus approfondi via des opérations d'analyse.

Utilisez la console GUI, Java ou une autre option pour effectuer la tâche.

Table de requête à l'aide de la console GUI

Effectuez quelques requêtes simples en utilisant les tables précédemment créées. Tout d'abord, ouvrez la console àhttps://console.aws.amazon.com/dynamodb

Choisir Tables dans le volet de navigation et sélectionnez Replydans la liste des tableaux. Sélectionnez ensuite leItems onglet pour voir les données chargées.

Sélectionnez le lien de filtrage des données ("Scan: [Table] Reply") sous le Create Item bouton.

Dans l'écran de filtrage, sélectionnez Requête pour l'opération. Entrez la valeur de clé de partition appropriée et cliquez surStart.

le Reply table renvoie ensuite les éléments correspondants.

Table de requête à l'aide de Java

Utilisez la méthode de requête en Java pour effectuer des opérations de récupération de données. Il faut spécifier la valeur de la clé de partition, la clé de tri étant facultative.

Codez une requête Java en créant d'abord un querySpec objectdécrivant les paramètres. Passez ensuite l'objet à la méthode de requête. Nous utilisons la clé de partition des exemples précédents.

Vous pouvez consulter l'exemple suivant -

import java.util.HashMap;
import java.util.Iterator;

import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
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;
import com.amazonaws.services.dynamodbv2.document.utils.NameMap;

public class ProductsQuery {  
   public static void main(String[] args) throws Exception {  
      AmazonDynamoDBClient client = new AmazonDynamoDBClient() 
         .withEndpoint("http://localhost:8000");  
      
      DynamoDB dynamoDB = new DynamoDB(client);  
      Table table = dynamoDB.getTable("Products");  
      HashMap<String, String> nameMap = new HashMap<String, String>(); 
      nameMap.put("#ID", "ID");  
      HashMap<String, Object> valueMap = new HashMap<String, Object>(); 
      valueMap.put(":xxx", 122);
      QuerySpec querySpec = new QuerySpec() 
         .withKeyConditionExpression("#ID = :xxx") 
         .withNameMap(new NameMap().with("#ID", "ID")) 
         .withValueMap(valueMap);  
      
      ItemCollection<QueryOutcome> items = null; 
      Iterator<Item> iterator = null; 
      Item item = null;  
      try { 
         System.out.println("Product with the ID 122"); 
         items = table.query(querySpec);  
         iterator = items.iterator(); 
         
         while (iterator.hasNext()) { 
            item = iterator.next(); 
            System.out.println(item.getNumber("ID") + ": " 
               + item.getString("Nomenclature")); 
         } 
      } catch (Exception e) { 
         System.err.println("Cannot find products with the ID number 122"); 
         System.err.println(e.getMessage()); 
      } 
   } 
}

Notez que la requête utilise la clé de partition, cependant, les index secondaires fournissent une autre option pour les requêtes. Leur flexibilité permet d'interroger des attributs non clés, un sujet qui sera abordé plus loin dans ce tutoriel.

La méthode d'analyse prend également en charge les opérations de récupération en rassemblant toutes les données de la table. leoptional .withFilterExpression empêche les éléments en dehors des critères spécifiés d'apparaître dans les résultats.

Plus tard dans ce tutoriel, nous discuterons scanningen détail. Maintenant, jetez un œil à l'exemple suivant -

import java.util.Iterator;

import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
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 ProductsScan {  
   public static void main(String[] args) throws Exception {  
      AmazonDynamoDBClient client = new AmazonDynamoDBClient() 
         .withEndpoint("http://localhost:8000");  
      
      DynamoDB dynamoDB = new DynamoDB(client);  
      Table table = dynamoDB.getTable("Products");  
      ScanSpec scanSpec = new ScanSpec() 
         .withProjectionExpression("#ID, Nomenclature , stat.sales") 
         .withFilterExpression("#ID between :start_id and :end_id") 
         .withNameMap(new NameMap().with("#ID",  "ID")) 
         .withValueMap(new ValueMap().withNumber(":start_id", 120)
         .withNumber(":end_id", 129));  
      
      try { 
         ItemCollection<ScanOutcome> items = table.scan(scanSpec);  
         Iterator<Item> iter = items.iterator(); 
        
         while (iter.hasNext()) {
            Item item = iter.next(); 
            System.out.println(item.toString()); 
         } 
      } catch (Exception e) { 
         System.err.println("Cannot perform a table scan:"); 
         System.err.println(e.getMessage()); 
      } 
   } 
}

Dans ce chapitre, nous discuterons de la manière dont nous pouvons supprimer une table ainsi que des différentes manières de supprimer une table.

La suppression de table est une opération simple nécessitant un peu plus que le nom de la table. Utilisez la console GUI, Java ou toute autre option pour effectuer cette tâche.

Supprimer la table à l'aide de la console GUI

Effectuez une opération de suppression en accédant d'abord à la console à -

https://console.aws.amazon.com/dynamodb.

Choisir Tables dans le volet de navigation, et choisissez la table que vous souhaitez supprimer dans la liste des tables, comme indiqué dans la capture d'écran suivante.

Enfin, sélectionnez Delete Table. Après avoir choisi Supprimer la table, une confirmation apparaît. Votre table est alors supprimée.

Supprimer la table à l'aide de Java

Utilisez le deleteméthode pour supprimer une table. Un exemple est donné ci-dessous pour mieux expliquer le concept.

import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient; 
import com.amazonaws.services.dynamodbv2.document.DynamoDB; 
import com.amazonaws.services.dynamodbv2.document.Table;  

public class ProductsDeleteTable {  
   public static void main(String[] args) throws Exception {  
      AmazonDynamoDBClient client = new AmazonDynamoDBClient() 
         .withEndpoint("http://localhost:8000"); 
      
      DynamoDB dynamoDB = new DynamoDB(client);  
      Table table = dynamoDB.getTable("Products");  
      try { 
         System.out.println("Performing table delete, wait..."); 
         table.delete(); 
         table.waitForDelete(); 
         System.out.print("Table successfully deleted.");  
      } catch (Exception e) { 
         System.err.println("Cannot perform table delete: "); 
         System.err.println(e.getMessage()); 
      } 
   } 
}

DynamoDB propose un large éventail d'outils API puissants pour la manipulation de tables, la lecture de données et la modification de données.

Amazon recommande d'utiliser AWS SDKs(par exemple, le SDK Java) plutôt que d'appeler des API de bas niveau. Les bibliothèques rendent l'interaction avec les API de bas niveau directement inutile. Les bibliothèques simplifient les tâches courantes telles que l'authentification, la sérialisation et les connexions.

Manipuler les tableaux

DynamoDB propose cinq actions de bas niveau pour la gestion des tables -

CreateTable- Cela génère une table et inclut le débit défini par l'utilisateur. Il vous oblige à définir une clé primaire, qu'elle soit composite ou simple. Il autorise également un ou plusieurs index secondaires.
ListTables - Cela fournit une liste de toutes les tables du compte de l'utilisateur AWS actuel et liées à leur point de terminaison.
UpdateTable - Cela modifie le débit et le débit de l'index secondaire global.
DescribeTable- Cela fournit des métadonnées de table; par exemple, l'état, la taille et les indices.
DeleteTable - Cela efface simplement la table et ses index.

Lire les données

DynamoDB propose quatre actions de bas niveau pour la lecture des données -

GetItem- Il accepte une clé primaire et renvoie les attributs de l'élément associé. Il permet de modifier son paramètre de lecture cohérent par défaut.
BatchGetItem- Il exécute plusieurs requêtes GetItem sur plusieurs éléments via des clés primaires, avec l'option d'une ou plusieurs tables. Ses retours ne dépassent pas 100 articles et doivent rester inférieurs à 16 Mo. Il permet finalement des lectures cohérentes et fortement cohérentes.
Scan- Il lit tous les éléments du tableau et produit un ensemble de résultats finalement cohérent. Vous pouvez filtrer les résultats par conditions. Il évite l'utilisation d'un index et scanne toute la table, ne l'utilisez donc pas pour les requêtes nécessitant une prévisibilité.
Query- Il renvoie un ou plusieurs éléments de table ou des éléments d'index secondaire. Il utilise une valeur spécifiée pour la clé de partition et permet l'utilisation d'opérateurs de comparaison pour restreindre la portée. Il prend en charge les deux types de cohérence, et chaque réponse obéit à une limite de 1 Mo en taille.

Modifier les données

DynamoDB propose quatre actions de bas niveau pour la modification des données -

PutItem- Cela génère un nouvel élément ou remplace les éléments existants. Lors de la découverte de clés primaires identiques, par défaut, il remplace l'élément. Les opérateurs conditionnels vous permettent de contourner la valeur par défaut et de ne remplacer les éléments que sous certaines conditions.
BatchWriteItem- Cela exécute à la fois plusieurs requêtes PutItem et DeleteItem, et sur plusieurs tables. Si une demande échoue, cela n'affecte pas toute l'opération. Son plafond est de 25 éléments et 16 Mo de taille.
UpdateItem - Il modifie les attributs d'élément existants et permet l'utilisation d'opérateurs conditionnels pour exécuter des mises à jour uniquement sous certaines conditions.
DeleteItem - Il utilise la clé primaire pour effacer un élément, et permet également l'utilisation d'opérateurs conditionnels pour spécifier les conditions de suppression.

La création d'un élément dans DynamoDB consiste principalement en une spécification d'élément et d'attribut, ainsi que la possibilité de spécifier des conditions. Chaque élément existe sous la forme d'un ensemble d'attributs, chaque attribut étant nommé et attribué à une valeur d'un certain type.

Les types de valeur incluent scalaire, document ou ensemble. Les articles ont une taille limite de 400 Ko, avec la possibilité de n'importe quel nombre d'attributs capables de s'adapter dans cette limite. Les tailles de nom et de valeur (longueurs binaires et UTF-8) déterminent la taille de l'élément. L'utilisation de noms d'attributs courts aide à réduire la taille des éléments.

Note- Vous devez spécifier tous les attributs de clé primaire, les clés primaires ne nécessitant que la clé de partition; et les clés composites nécessitant à la fois la clé de partition et de tri.

Souvenez-vous également que les tables ne possèdent pas de schéma prédéfini. Vous pouvez stocker des ensembles de données radicalement différents dans une seule table.

Utilisez la console GUI, Java ou un autre outil pour effectuer cette tâche.

Comment créer un élément à l'aide de la console GUI?

Accédez à la console. Dans le volet de navigation sur le côté gauche, sélectionnezTables. Choisissez le nom de la table à utiliser comme destination, puis sélectionnez leItems onglet comme indiqué dans la capture d'écran suivante.

Sélectionner Create Item. L'écran Créer un article fournit une interface pour saisir les valeurs d'attribut requises. Tous les indices secondaires doivent également être saisis.

Si vous avez besoin de plus d'attributs, sélectionnez le menu d'action à gauche du Message. Puis sélectionnezAppendet le type de données souhaité.

Après avoir saisi toutes les informations essentielles, sélectionnez Save pour ajouter l'élément.

Comment utiliser Java dans la création d'articles?

L'utilisation de Java dans les opérations de création d'élément consiste à créer une instance de classe DynamoDB, une instance de classe Table, une instance de classe Item et à spécifier la clé primaire et les attributs de l'élément que vous allez créer. Ajoutez ensuite votre nouvel élément avec la méthode putItem.

Exemple

DynamoDB dynamoDB = new DynamoDB (new AmazonDynamoDBClient(
   new ProfileCredentialsProvider()));
Table table = dynamoDB.getTable("ProductList");
   
// Spawn a related items list 
List<Number> RELItems = new ArrayList<Number>(); 
RELItems.add(123); 
RELItems.add(456); 
RELItems.add(789);  
   
//Spawn a product picture map  
Map<String, String> photos = new HashMap<String, String>(); 
photos.put("Anterior", "http://xyz.com/products/101_front.jpg"); 
photos.put("Posterior", "http://xyz.com/products/101_back.jpg"); 
photos.put("Lateral", "http://xyz.com/products/101_LFTside.jpg");  

//Spawn a product review map 
Map<String, List<String>> prodReviews = new HashMap<String, List<String>>();  
List<String> fiveStarRVW = new ArrayList<String>(); 
fiveStarRVW.add("Shocking high performance."); 
fiveStarRVW.add("Unparalleled in its market."); 
prodReviews.put("5 Star", fiveStarRVW);  
List<String> oneStarRVW = new ArrayList<String>(); 
oneStarRVW.add("The worst offering in its market."); 
prodReviews.put("1 Star", oneStarRVW);  

// Generate the item 
Item item = new Item()
   .withPrimaryKey("Id", 101) 
   .withString("Nomenclature", "PolyBlaster 101") 
   .withString("Description", "101 description") 
   .withString("Category", "Hybrid Power Polymer Cutter")  
   .withString("Make", "Brand – XYZ") 
   .withNumber("Price", 50000) 
   .withString("ProductCategory", "Laser Cutter") 
   .withBoolean("Availability", true) 
   .withNull("Qty") 
   .withList("ItemsRelated", RELItems) 
   .withMap("Images", photos) 
   .withMap("Reviews", prodReviews);

// Add item to the table  
PutItemOutcome outcome = table.putItem(item);

Vous pouvez également consulter l'exemple plus large suivant.

Note- L'exemple suivant peut supposer une source de données précédemment créée. Avant de tenter de l'exécuter, acquérez les bibliothèques de prise en charge et créez les sources de données nécessaires (tables avec les caractéristiques requises ou autres sources référencées).

L'exemple suivant utilise également Eclipse IDE, un fichier d'informations d'identification AWS et AWS Toolkit dans un projet Eclipse AWS Java.

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.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
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;

public class CreateItemOpSample { 
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient ( 
      new ProfileCredentialsProvider()));  
   static String tblName = "ProductList";  
      
   public static void main(String[] args) throws IOException {  
      createItems();  
      retrieveItem();  
         
      // Execute updates 
      updateMultipleAttributes(); 
      updateAddNewAttribute(); 
      updateExistingAttributeConditionally();  
         
      // Item deletion 
      deleteItem();  
   }
   private static void createItems() {  
      Table table = dynamoDB.getTable(tblName); 
      try {  
         Item item = new Item() 
            .withPrimaryKey("ID", 303)
            .withString("Nomenclature", "Polymer Blaster 4000") 
            .withStringSet( "Manufacturers", 
            new HashSet<String>(Arrays.asList("XYZ Inc.", "LMNOP Inc.")))  
            .withNumber("Price", 50000) 
            .withBoolean("InProduction", true) 
            .withString("Category", "Laser Cutter"); 
         
         table.putItem(item);  
         item = new Item() 
            .withPrimaryKey("ID", 313) 
            .withString("Nomenclature", "Agitatatron 2000") 
            .withStringSet( "Manufacturers", 
            new HashSet<String>(Arrays.asList("XYZ Inc,", "CDE Inc."))) 
            .withNumber("Price", 40000) 
            .withBoolean("InProduction", true) 
            .withString("Category", "Agitator"); 
         
         table.putItem(item);  
      } catch (Exception e) { 
         System.err.println("Cannot create items."); 
         System.err.println(e.getMessage()); 
      } 
   }   
}

La récupération d'un élément dans DynamoDB nécessite l'utilisation de GetItem et la spécification du nom de la table et de la clé primaire de l'élément. Assurez-vous d'inclure une clé primaire complète plutôt que d'omettre une partie.

Par exemple, omettre la clé de tri d'une clé composite.

Le comportement de GetItem est conforme à trois valeurs par défaut -

Il s'exécute comme une lecture finalement cohérente.
Il fournit tous les attributs.
Il ne détaille pas sa consommation unitaire de capacité.

Ces paramètres vous permettent de remplacer le comportement par défaut de GetItem.

Récupérer un élément

DynamoDB garantit la fiabilité en conservant plusieurs copies des éléments sur plusieurs serveurs. Chaque écriture réussie crée ces copies, mais prend un temps considérable à exécuter; signifiant finalement cohérent. Cela signifie que vous ne pouvez pas tenter une lecture immédiatement après avoir écrit un élément.

Vous pouvez modifier la lecture cohérente par défaut de GetItem, cependant, le coût des données plus actuelles reste la consommation d'unités de capacité plus; plus précisément, deux fois plus. Remarque DynamoDB atteint généralement la cohérence entre chaque copie en une seconde.

Vous pouvez utiliser la console GUI, Java ou un autre outil pour effectuer cette tâche.

Récupération d'éléments à l'aide de Java

L'utilisation de Java dans les opérations de récupération d'éléments nécessite la création d'une instance de classe DynamoDB, une instance de classe de table et l'appel de la méthode getItem de l'instance de table. Spécifiez ensuite la clé primaire de l'élément.

Vous pouvez consulter l'exemple suivant -

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
   new ProfileCredentialsProvider()));  
Table table = dynamoDB.getTable("ProductList");  
Item item = table.getItem("IDnum", 109);

Dans certains cas, vous devez spécifier les paramètres de cette opération.

L'exemple suivant utilise .withProjectionExpression et GetItemSpec pour les spécifications de récupération -

GetItemSpec spec = new GetItemSpec() 
   .withPrimaryKey("IDnum", 122) 
   .withProjectionExpression("IDnum, EmployeeName, Department") 
   .withConsistentRead(true);

Item item = table.getItem(spec);
System.out.println(item.toJSONPretty());

Vous pouvez également consulter un exemple plus détaillé suivant pour une meilleure compréhension.

Cet exemple utilise également Eclipse IDE, un fichier d'informations d'identification AWS et AWS Toolkit dans un projet Eclipse AWS Java.

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.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
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;

public class GetItemOpSample {
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient(
      new ProfileCredentialsProvider()));
   
   static String tblName = "ProductList";
   public static void main(String[] args) throws IOException {
      createItems();
      retrieveItem();
      
      // Execute updates
      updateMultipleAttributes();
      updateAddNewAttribute();
      updateExistingAttributeConditionally();
      
      // Item deletion
      deleteItem();
   }
   private static void createItems() {
      Table table = dynamoDB.getTable(tblName);
      try {
         Item item = new Item()
            .withPrimaryKey("ID", 303)
            .withString("Nomenclature", "Polymer Blaster 4000")
            .withStringSet( "Manufacturers",
            new HashSet<String>(Arrays.asList("XYZ Inc.", "LMNOP Inc.")))
            .withNumber("Price", 50000)
            .withBoolean("InProduction", true)
            .withString("Category", "Laser Cutter");
            table.putItem(item);
            
         item = new Item()
            .withPrimaryKey("ID", 313)
            .withString("Nomenclature", "Agitatatron 2000")
            .withStringSet( "Manufacturers",
            new HashSet<String>(Arrays.asList("XYZ Inc,", "CDE Inc.")))
            .withNumber("Price", 40000)
            .withBoolean("InProduction", true)
            .withString("Category", "Agitator");
         
         table.putItem(item);
      } catch (Exception e) {
         System.err.println("Cannot create items.");
         System.err.println(e.getMessage());
      }
   }
   private static void retrieveItem() {
      Table table = dynamoDB.getTable(tableName);
      try {
         Item item = table.getItem("ID", 303, "ID, Nomenclature, Manufacturers", null);
         System.out.println("Displaying retrieved items...");
         System.out.println(item.toJSONPretty());
      } catch (Exception e) {
         System.err.println("Cannot retrieve items.");
         System.err.println(e.getMessage());
      }
   }
}

La mise à jour d'un élément dans DynamoDB consiste principalement à spécifier la clé primaire complète et le nom de table de l'élément. Il nécessite une nouvelle valeur pour chaque attribut que vous modifiez. L'opération utiliseUpdateItem, qui modifie les éléments existants ou les crée lors de la découverte d'un élément manquant.

Dans les mises à jour, vous souhaiterez peut-être suivre les modifications en affichant les valeurs d'origine et les nouvelles valeurs, avant et après les opérations. UpdateItem utilise leReturnValues paramètre pour y parvenir.

Note - L'opération ne rapporte pas la consommation d'unité de capacité, mais vous pouvez utiliser ReturnConsumedCapacity paramètre.

Utilisez la console GUI, Java ou tout autre outil pour effectuer cette tâche.

Comment mettre à jour des éléments à l'aide des outils GUI?

Accédez à la console. Dans le volet de navigation sur le côté gauche, sélectionnezTables. Choisissez la table nécessaire, puis sélectionnez leItems languette.

Choisissez l'élément souhaité pour une mise à jour et sélectionnez Actions | Edit.

Modifiez les attributs ou valeurs nécessaires dans le Edit Item la fenêtre.

Mettre à jour les éléments à l'aide de Java

L'utilisation de Java dans les opérations de mise à jour des éléments nécessite la création d'une instance de classe Table et l'appel de son updateItemméthode. Ensuite, vous spécifiez la clé primaire de l'élément et fournissez unUpdateExpression détaillant les modifications d'attributs.

Ce qui suit est un exemple de la même chose -

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient(
   new ProfileCredentialsProvider()));
   
Table table = dynamoDB.getTable("ProductList");

Map<String, String> expressionAttributeNames = new HashMap<String, String>();
expressionAttributeNames.put("#M", "Make");
expressionAttributeNames.put("#P", "Price
expressionAttributeNames.put("#N", "ID");

Map<String, Object> expressionAttributeValues = new HashMap<String, Object>();
expressionAttributeValues.put(":val1",
   new HashSet<String>(Arrays.asList("Make1","Make2")));
expressionAttributeValues.put(":val2", 1);       //Price

UpdateItemOutcome outcome =  table.updateItem(
   "internalID",                                 // key attribute name
   111,                                          // key attribute value
   "add #M :val1 set #P = #P - :val2 remove #N", // UpdateExpression
   expressionAttributeNames,
   expressionAttributeValues);

le updateItem La méthode permet également de spécifier des conditions, qui peuvent être vues dans l'exemple suivant -

Table table = dynamoDB.getTable("ProductList");
Map<String, String> expressionAttributeNames = new HashMap<String, String>();
expressionAttributeNames.put("#P", "Price");

Map<String, Object> expressionAttributeValues = new HashMap<String, Object>();
expressionAttributeValues.put(":val1", 44);  // change Price to 44
expressionAttributeValues.put(":val2", 15);  // only if currently 15

UpdateItemOutcome outcome = table.updateItem (new PrimaryKey("internalID",111),
   "set #P = :val1",                        // Update
   "#P = :val2",                            // Condition 
   expressionAttributeNames,
   expressionAttributeValues);

Mettre à jour les éléments à l'aide de compteurs

DynamoDB autorise les compteurs atomiques, ce qui signifie utiliser UpdateItem pour incrémenter / décrémenter les valeurs d'attribut sans affecter les autres demandes; de plus, les compteurs sont toujours mis à jour.

Voici un exemple qui explique comment cela peut être fait.

Cet exemple utilise également Eclipse IDE, un fichier d'informations d'identification AWS et AWS Toolkit dans un projet Eclipse AWS Java.

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.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
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;

public class UpdateItemOpSample {  
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
      new ProfileCredentialsProvider()));  
   static String tblName = "ProductList";  
   
   public static void main(String[] args) throws IOException {  
      createItems();  
      retrieveItem();  
      
      // Execute updates 
      updateMultipleAttributes(); 
      updateAddNewAttribute();
      updateExistingAttributeConditionally();  
      
      // Item deletion 
      deleteItem(); 
   }
   private static void createItems() {  
      Table table = dynamoDB.getTable(tblName); 
      try { 
         Item item = new Item() 
            .withPrimaryKey("ID", 303) 
            .withString("Nomenclature", "Polymer Blaster 4000") 
            .withStringSet( "Manufacturers",
            new HashSet<String>(Arrays.asList("XYZ Inc.", "LMNOP Inc."))) 
            .withNumber("Price", 50000) 
            .withBoolean("InProduction", true) 
            .withString("Category", "Laser Cutter"); 
            table.putItem(item);  
         
         item = new Item() 
            .withPrimaryKey("ID", 313) 
            .withString("Nomenclature", "Agitatatron 2000") 
            .withStringSet( "Manufacturers", 
            new HashSet<String>(Arrays.asList("XYZ Inc,", "CDE Inc."))) 
            .withNumber("Price", 40000) 
            .withBoolean("InProduction", true) 
            .withString("Category", "Agitator");  
            table.putItem(item);  
      } catch (Exception e) { 
         System.err.println("Cannot create items."); 
         System.err.println(e.getMessage()); 
      } 
   }
   private static void updateAddNewAttribute() { 
      Table table = dynamoDB.getTable(tableName);  
      try {  
         Map<String, String> expressionAttributeNames = new HashMap<String, String>(); 
         expressionAttributeNames.put("#na", "NewAttribute");  
         UpdateItemSpec updateItemSpec = new UpdateItemSpec() 
            .withPrimaryKey("ID", 303) 
            .withUpdateExpression("set #na = :val1") 
            .withNameMap(new NameMap() 
            .with("#na", "NewAttribute")) 
            .withValueMap(new ValueMap() 
            .withString(":val1", "A value")) 
            .withReturnValues(ReturnValue.ALL_NEW);  
            UpdateItemOutcome outcome =  table.updateItem(updateItemSpec);  
         
         // Confirm 
         System.out.println("Displaying updated item..."); 
         System.out.println(outcome.getItem().toJSONPretty());             
      } catch (Exception e) { 
         System.err.println("Cannot add an attribute in " + tableName); 
         System.err.println(e.getMessage()); 
      }         
   } 
}

La suppression d'un élément dans DynamoDB nécessite uniquement de fournir le nom de la table et la clé d'élément. Il est également fortement recommandé d'utiliser une expression conditionnelle qui sera nécessaire pour éviter de supprimer les mauvais éléments.

Comme d'habitude, vous pouvez utiliser la console GUI, Java ou tout autre outil nécessaire pour effectuer cette tâche.

Supprimer des éléments à l'aide de la console GUI

Accédez à la console. Dans le volet de navigation sur le côté gauche, sélectionnezTables. Sélectionnez ensuite le nom de la table et leItems languette.

Choisissez les éléments que vous souhaitez supprimer et sélectionnez Actions | Delete.

UNE Delete Item(s)La boîte de dialogue apparaît alors comme indiqué dans la capture d'écran suivante. Choisissez «Supprimer» pour confirmer.

Comment supprimer des éléments à l'aide de Java?

L'utilisation de Java dans les opérations de suppression d'éléments implique simplement la création d'une instance client DynamoDB et l'appel de deleteItem méthode en utilisant la clé de l'élément.

Vous pouvez voir l'exemple suivant, où il a été expliqué en détail.

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
   new ProfileCredentialsProvider()));
   
Table table = dynamoDB.getTable("ProductList");
DeleteItemOutcome outcome = table.deleteItem("IDnum", 151);

Vous pouvez également spécifier les paramètres à protéger contre une suppression incorrecte. Utilisez simplement unConditionExpression.

Par exemple -

Map<String,Object> expressionAttributeValues = new HashMap<String,Object>(); 
expressionAttributeValues.put(":val", false);
  
DeleteItemOutcome outcome = table.deleteItem("IDnum",151, 
   "Ship = :val",  
   null,                   // doesn't use ExpressionAttributeNames  
   expressionAttributeValues);

Voici un exemple plus large pour une meilleure compréhension.

Cet exemple utilise également Eclipse IDE, un fichier d'informations d'identification AWS et AWS Toolkit dans un projet Eclipse AWS Java.

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.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
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;

public class DeleteItemOpSample {  
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
      new ProfileCredentialsProvider()));  
   
   static String tblName = "ProductList";  
   public static void main(String[] args) throws IOException { 
      createItems(); 
      retrieveItem();  
      
      // Execute updates 
      updateMultipleAttributes(); 
      updateAddNewAttribute(); 
      updateExistingAttributeConditionally();  
      
      // Item deletion 
      deleteItem();  
   }  
   private static void createItems() {  
      Table table = dynamoDB.getTable(tblName); 
      try {  
         Item item = new Item()  
            .withPrimaryKey("ID", 303) 
            .withString("Nomenclature", "Polymer Blaster 4000")
            .withStringSet( "Manufacturers",
            new HashSet<String>(Arrays.asList("XYZ Inc.", "LMNOP Inc."))) 
            .withNumber("Price", 50000) 
            .withBoolean("InProduction", true) 
            .withString("Category", "Laser Cutter"); 
            table.putItem(item);  
         
         item = new Item() 
            .withPrimaryKey("ID", 313) 
            .withString("Nomenclature", "Agitatatron 2000") 
            .withStringSet( "Manufacturers", 
            new HashSet<String>(Arrays.asList("XYZ Inc,", "CDE Inc."))) 
            .withNumber("Price", 40000) 
            .withBoolean("InProduction", true) 
            .withString("Category", "Agitator"); 
            table.putItem(item);  
      } catch (Exception e) { 
         System.err.println("Cannot create items."); 
         System.err.println(e.getMessage());  
      } 
   }  
   private static void deleteItem() {  
      Table table = dynamoDB.getTable(tableName);  
      try {  
         DeleteItemSpec deleteItemSpec = new DeleteItemSpec() 
            .withPrimaryKey("ID", 303)  
            .withConditionExpression("#ip = :val") 
            .withNameMap(new NameMap() 
            .with("#ip", "InProduction"))
            .withValueMap(new ValueMap() 
            .withBoolean(":val", false)) 
            .withReturnValues(ReturnValue.ALL_OLD);  
         DeleteItemOutcome outcome = table.deleteItem(deleteItemSpec);  
         
         // Confirm 
         System.out.println("Displaying deleted item..."); 
         System.out.println(outcome.getItem().toJSONPretty());  
      } catch (Exception e) { 
         System.err.println("Cannot delete item in " + tableName); 
         System.err.println(e.getMessage()); 
      } 
   } 
}

L'écriture par lots opère sur plusieurs éléments en créant ou en supprimant plusieurs éléments. Ces opérations utilisentBatchWriteItem, qui comporte les limites de pas plus de 16 Mo d'écritures et de 25 requêtes. Chaque élément obéit à une limite de taille de 400 Ko. Les écritures par lots ne peuvent pas non plus effectuer de mises à jour d'éléments.

Qu'est-ce que l'écriture par lots?

Les écritures par lots peuvent manipuler des éléments sur plusieurs tables. L'appel d'opération se produit pour chaque demande individuelle, ce qui signifie que les opérations n'ont pas d'impact les unes sur les autres et que les mélanges hétérogènes sont autorisés; par exemple, unPutItem et trois DeleteItemrequêtes dans un lot, l'échec de la requête PutItem n'affectant pas les autres. Les demandes ayant échoué entraînent le retour des informations (clés et données) relatives à chaque demande échouée.

Note- Si DynamoDB renvoie des éléments sans les traiter, réessayez-les; cependant, utilisez une méthode d'interruption pour éviter un autre échec de demande basé sur une surcharge.

DynamoDB rejette une opération d'écriture par lots lorsqu'une ou plusieurs des instructions suivantes s'avèrent vraies -

La demande dépasse le débit alloué.
La demande tente d'utiliser BatchWriteItems pour mettre à jour un élément.
La demande effectue plusieurs opérations sur un seul élément.
Les tables de requêtes n'existent pas.
Les attributs d'élément dans la demande ne correspondent pas à la cible.
Les demandes dépassent les limites de taille.

Les écritures par lots nécessitent certaines RequestItem paramètres -

Les opérations de suppression nécessitent DeleteRequest clé subelements signifiant un nom et une valeur d'attribut.
le PutRequest les articles nécessitent un Item subelement signifiant une carte d'attribut et de valeur d'attribut.

Response - Une opération réussie entraîne une réponse HTTP 200, qui indique des caractéristiques telles que les unités de capacité consommées, les métriques de traitement de table et tout élément non traité.

Écrit par lots avec Java

Effectuez une écriture par lots en créant une instance de classe DynamoDB, un TableWriteItems instance de classe décrivant toutes les opérations et appelant le batchWriteItem méthode pour utiliser l'objet TableWriteItems.

Note- Vous devez créer une instance TableWriteItems pour chaque table dans une écriture par lots dans plusieurs tables. Vérifiez également votre réponse à la demande pour toute demande non traitée.

Vous pouvez consulter l'exemple suivant d'écriture par lots -

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
   new ProfileCredentialsProvider()));  

TableWriteItems forumTableWriteItems = new TableWriteItems("Forum") 
   .withItemsToPut( 
   new Item() 
   .withPrimaryKey("Title", "XYZ CRM") 
   .withNumber("Threads", 0));  

TableWriteItems threadTableWriteItems = new TableWriteItems(Thread) 
   .withItemsToPut( 
   new Item() 
   .withPrimaryKey("ForumTitle","XYZ CRM","Topic","Updates") 
   .withHashAndRangeKeysToDelete("ForumTitle","A partition key value", 
   "Product Line 1", "A sort key value"));

BatchWriteItemOutcome outcome = dynamoDB.batchWriteItem (
   forumTableWriteItems, threadTableWriteItems);

Le programme suivant est un autre exemple plus complet permettant de mieux comprendre comment un lot écrit avec Java.

Cet exemple utilise également Eclipse IDE, un fichier d'informations d'identification AWS et AWS Toolkit dans un projet Eclipse AWS Java.

package com.amazonaws.codesamples.document;

import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Map;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
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 BatchWriteOpSample {  
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
      new ProfileCredentialsProvider()));  
   static String forumTableName = "Forum"; 
   static String threadTableName = "Thread";  
      
   public static void main(String[] args) throws IOException { 
      batchWriteMultiItems();   
   }
   private static void batchWriteMultiItems() { 
      try {
         // Place new item in Forum 
         TableWriteItems forumTableWriteItems = new TableWriteItems(forumTableName) 
                                                                       //Forum 
            .withItemsToPut(new Item() 
            .withPrimaryKey("Name", "Amazon RDS") 
            .withNumber("Threads", 0));  
            
         // Place one item, delete another in Thread 
         // Specify partition key and range key 
         TableWriteItems threadTableWriteItems = new TableWriteItems(threadTableName) 
            .withItemsToPut(new Item() 
            .withPrimaryKey("ForumName","Product  
            Support","Subject","Support Thread 1") 
            .withString("Message", "New OS Thread 1 message")
            .withHashAndRangeKeysToDelete("ForumName","Subject", "Polymer Blaster", 
            "Support Thread 100"));  
            
         System.out.println("Processing request..."); 
         BatchWriteItemOutcome outcome = dynamoDB.batchWriteItem (
               forumTableWriteItems, threadTableWriteItems);
         do {  
            // Confirm no unprocessed items 
            Map<String, List<WriteRequest>> unprocessedItems 
               = outcome.getUnprocessedItems();  
                  
            if (outcome.getUnprocessedItems().size() == 0) { 
               System.out.println("All items processed."); 
            } else { 
               System.out.println("Gathering unprocessed items..."); 
               outcome = dynamoDB.batchWriteItemUnprocessed(unprocessedItems); 
            }  
         } while (outcome.getUnprocessedItems().size() > 0);  
      } catch (Exception e) { 
         System.err.println("Could not get items: "); 
         e.printStackTrace(System.err); 
      }   
   } 
}

Les opérations de récupération par lots renvoient les attributs d'un ou de plusieurs éléments. Ces opérations consistent généralement à utiliser la clé primaire pour identifier le ou les éléments souhaités. leBatchGetItem les opérations sont soumises aux limites des opérations individuelles ainsi qu'à leurs propres contraintes uniques.

Les requêtes suivantes dans les opérations de récupération par lots entraînent un rejet -

Faites une demande pour plus de 100 articles.
Faites une demande dépassant le débit.

Les opérations de récupération par lots effectuent un traitement partiel des demandes susceptibles de dépasser les limites.

For example- une demande de récupération de plusieurs éléments de taille suffisante pour dépasser les limites entraîne une partie du traitement de la demande et un message d'erreur indiquant la partie non traitée. Au retour des éléments non traités, créez une solution d'algorithme de back-off pour gérer cela plutôt que de limiter les tables.

le BatchGetles opérations s'effectuent finalement avec des lectures cohérentes, nécessitant des modifications pour celles qui sont fortement cohérentes. Ils effectuent également des récupérations en parallèle.

Note- L'ordre des articles retournés. DynamoDB ne trie pas les éléments. Il n'indique pas non plus l'absence des articles demandés. De plus, ces demandes consomment des unités de capacité.

Toutes les opérations BatchGet nécessitent RequestItems des paramètres tels que la cohérence de lecture, les noms d'attributs et les clés primaires.

Récupérations par lots avec Java

L'utilisation de Java dans les opérations BatchGet nécessite la création d'une instance de classe DynamoDB, TableKeysAndAttributes instance de classe décrivant une liste de valeurs de clé primaire pour les éléments et passant l'objet TableKeysAndAttributes à BatchGetItem méthode.

Voici un exemple d'opération BatchGet -

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient ( 
   new ProfileCredentialsProvider()));  

TableKeysAndAttributes forumTableKeysAndAttributes = new TableKeysAndAttributes 
   (forumTableName);
   
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys (
   "Title",
   "Updates",  
   "Product Line 1"
); 
TableKeysAndAttributes threadTableKeysAndAttributes = new TableKeysAndAttributes (
   threadTableName);
      
threadTableKeysAndAttributes.addHashAndRangePrimaryKeys (
   "ForumTitle",
   "Topic",  
   "Product Line 1",
   "P1 Thread 1", 
   "Product Line 1",
   "P1 Thread 2", 
   "Product Line 2",
   "P2 Thread 1"
); 
BatchGetItemOutcome outcome = dynamoDB.batchGetItem ( 
   forumTableKeysAndAttributes, threadTableKeysAndAttributes);
      
for (String tableName : outcome.getTableItems().keySet()) { 
   System.out.println("Table items " + tableName); 
   List<Item> items = outcome.getTableItems().get(tableName); 
   for (Item item : items) { 
      System.out.println(item); 
   } 
}

Vous pouvez consulter l'exemple plus large suivant.

Note- Le programme suivant peut supposer une source de données précédemment créée. Avant de tenter de l'exécuter, acquérez les bibliothèques de prise en charge et créez les sources de données nécessaires (tables avec les caractéristiques requises ou autres sources référencées).

Ce programme utilise également Eclipse IDE, un fichier d'informations d'identification AWS et AWS Toolkit dans un projet Eclipse AWS Java.

package com.amazonaws.codesamples.document;

import java.io.IOException;
import java.util.List;
import java.util.Map;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
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 BatchGetOpSample { 
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient ( 
      new ProfileCredentialsProvider())); 
      
   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); 
         
         //Create partition key 
         forumTableKeysAndAttributes.addHashOnlyPrimaryKeys (
            "Name", 
            "XYZ Melt-O-tron", 
            "High-Performance Processing"
         ); 
         TableKeysAndAttributes threadTableKeysAndAttributes = 
            new TableKeysAndAttributes(threadTableName); 
         
         //Create partition key and sort key 
         threadTableKeysAndAttributes.addHashAndRangePrimaryKeys (
            "ForumName",
            "Subject",  
            "High-Performance Processing",
            "HP Processing Thread One", 
            "High-Performance Processing",
            "HP Processing Thread Two", 
            "Melt-O-Tron",
            "MeltO Thread One"
         );
         System.out.println("Processing..."); 
         BatchGetItemOutcome outcome = dynamoDB.batchGetItem(forumTableKeysAndAttributes,
            threadTableKeysAndAttributes); 
              
         Map<String, KeysAndAttributes> unprocessed = null;    
         do { 
            for (String tableName : outcome.getTableItems().keySet()) { 
               System.out.println("Table items for " + tableName); 
               List<Item> items = outcome.getTableItems().get(tableName); 
               
               for (Item item : items) { 
                  System.out.println(item.toJSONPretty()); 
               } 
            } 
            // Confirm no unprocessed items 
            unprocessed = outcome.getUnprocessedKeys(); 
                 
            if (unprocessed.isEmpty()) { 
               System.out.println("All items processed."); 
            } else { 
               System.out.println("Gathering unprocessed items..."); 
               outcome = dynamoDB.batchGetItemUnprocessed(unprocessed); 
            } 
         } while (!unprocessed.isEmpty()); 
      } catch (Exception e) { 
         System.err.println("Could not get items."); 
         System.err.println(e.getMessage()); 
      }   
   } 
}

Les requêtes localisent des éléments ou des index secondaires via des clés primaires. L'exécution d'une requête nécessite une clé de partition et une valeur spécifique, ou une clé de tri et une valeur; avec la possibilité de filtrer avec des comparaisons. Le comportement par défaut d'une requête consiste à renvoyer tous les attributs des éléments associés à la clé primaire fournie. Cependant, vous pouvez spécifier les attributs souhaités avec leProjectionExpression paramètre.

Une requête utilise le KeyConditionExpressionparamètres pour sélectionner des éléments, ce qui nécessite de fournir le nom et la valeur de la clé de partition sous la forme d'une condition d'égalité. Vous avez également la possibilité de fournir une condition supplémentaire pour les clés de tri présentes.

Quelques exemples de conditions de clé de tri sont:

Sr.Non	Description de la condition
1	x = y Il prend la valeur true si l'attribut x est égal à y.
2	x < y Il prend la valeur true si x est inférieur à y.
3	x <= y Il prend la valeur true si x est inférieur ou égal à y.
4	x > y Il prend la valeur true si x est supérieur à y.
5	x >= y Il prend la valeur true si x est supérieur ou égal à y.
6	x BETWEEN y AND z Il prend la valeur true si x est à la fois> = y et <= z.

DynamoDB prend également en charge les fonctions suivantes: begins_with (x, substr)

Il prend la valeur true si l'attribut x commence par la chaîne spécifiée.

Les conditions suivantes doivent être conformes à certaines exigences -

Les noms d'attribut doivent commencer par un caractère dans le jeu az ou AZ.
Le deuxième caractère d'un nom d'attribut doit appartenir à l'ensemble az, AZ ou 0-9.
Les noms d'attribut ne peuvent pas utiliser de mots réservés.

Les noms d'attributs non conformes aux contraintes ci-dessus peuvent définir un espace réservé.

La requête est traitée en effectuant des extractions dans l'ordre des clés de tri et en utilisant toutes les expressions de condition et de filtre présentes. Les requêtes renvoient toujours un jeu de résultats et, en l'absence de correspondances, elles renvoient un jeu vide.

Les résultats retournent toujours dans l'ordre des clés de tri et dans l'ordre basé sur le type de données avec la valeur par défaut modifiable comme ordre croissant.

Interroger avec Java

Les requêtes en Java vous permettent d'interroger des tables et des index secondaires. Ils nécessitent la spécification des clés de partition et des conditions d'égalité, avec la possibilité de spécifier des clés de tri et des conditions.

Les étapes générales requises pour une requête en Java incluent la création d'une instance de classe DynamoDB, une instance de classe Table pour la table cible et l'appel de la méthode de requête de l'instance Table pour recevoir l'objet de requête.

La réponse à la requête contient un ItemCollection objet fournissant tous les articles retournés.

L'exemple suivant illustre une requête détaillée -

DynamoDB dynamoDB = new DynamoDB (
   new AmazonDynamoDBClient(new ProfileCredentialsProvider()));

Table table = dynamoDB.getTable("Response");  
   QuerySpec spec = new QuerySpec() 
   .withKeyConditionExpression("ID = :nn") 
.withValueMap(new ValueMap() 
   .withString(":nn", "Product Line 1#P1 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());
}

La méthode de requête prend en charge une grande variété de paramètres facultatifs. L'exemple suivant montre comment utiliser ces paramètres -

Table table = dynamoDB.getTable("Response");  
QuerySpec spec = new QuerySpec() 
   .withKeyConditionExpression("ID = :nn and ResponseTM > :nn_responseTM")  
   .withFilterExpression("Author = :nn_author") 
   .withValueMap(new ValueMap()
   .withString(":nn", "Product Line 1#P1 Thread 1") 
   .withString(":nn_responseTM", twoWeeksAgoStr) 
   .withString(":nn_author", "Member 123"))
   .withConsistentRead(true);
   
ItemCollection<QueryOutcome> items = table.query(spec);  
Iterator<Item> iterator = items.iterator(); 

while (iterator.hasNext()) { 
   System.out.println(iterator.next().toJSONPretty()); 
}

Vous pouvez également consulter l'exemple plus large suivant.

Cet exemple utilise également Eclipse IDE, un fichier d'informations d'identification AWS et AWS Toolkit dans un projet Eclipse AWS Java.

package com.amazonaws.codesamples.document;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
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 QueryOpSample {
   static DynamoDB dynamoDB = new DynamoDB(
      new AmazonDynamoDBClient(new ProfileCredentialsProvider()));
   static String tableName = "Reply";  
   
   public static void main(String[] args) throws Exception { 
      String forumName = "PolyBlaster"; 
      String threadSubject = "PolyBlaster Thread 1";  
      getThreadReplies(forumName, threadSubject); 
   } 
   private static void getThreadReplies(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("\ngetThreadReplies results:"); 
      Iterator<Item> iterator = items.iterator(); 
      
      while (iterator.hasNext()) { 
         System.out.println(iterator.next().toJSONPretty()); 
      } 
   } 
}

Les opérations d'analyse lisent tous les éléments de la table ou les index secondaires. Sa fonction par défaut entraîne le renvoi de tous les attributs de données de tous les éléments d'un index ou d'une table. Employer leProjectionExpression paramètre dans les attributs de filtrage.

Chaque analyse renvoie un jeu de résultats, même si aucune correspondance n'est trouvée, ce qui donne un jeu vide. Les analyses ne récupèrent pas plus de 1 Mo, avec la possibilité de filtrer les données.

Note - Les paramètres et le filtrage des scans s'appliquent également aux requêtes.

Types d'opérations de scan

Filtering- Les opérations d'analyse offrent un filtrage fin à travers des expressions de filtre, qui modifient les données après des analyses ou des requêtes; avant de renvoyer les résultats. Les expressions utilisent des opérateurs de comparaison. Leur syntaxe ressemble aux expressions de condition à l'exception des attributs clés, que les expressions de filtre ne permettent pas. Vous ne pouvez pas utiliser de partition ou de clé de tri dans une expression de filtre.

Note - La limite de 1 Mo s'applique avant toute application de filtrage.

Throughput Specifications- Les analyses consomment du débit, cependant, la consommation se concentre sur la taille de l'élément plutôt que sur les données renvoyées. La consommation reste la même, que vous demandiez tous les attributs ou seulement quelques-uns, et l'utilisation ou non d'une expression de filtre n'a pas non plus d'impact sur la consommation.

Pagination- DynamoDB pagine les résultats provoquant la division des résultats en pages spécifiques. La limite de 1 Mo s'applique aux résultats renvoyés et lorsque vous la dépassez, une autre analyse est nécessaire pour collecter le reste des données. leLastEvaluatedKeyvalue vous permet d'effectuer cette analyse ultérieure. Appliquez simplement la valeur auExclusiveStartkey. Quand leLastEvaluatedKeyvalue devient nulle, l'opération a terminé toutes les pages de données. Cependant, une valeur non nulle ne signifie pas automatiquement qu'il reste plus de données. Seule une valeur nulle indique l'état.

The Limit Parameter- Le paramètre limit gère la taille du résultat. DynamoDB l'utilise pour établir le nombre d'éléments à traiter avant de renvoyer des données et ne fonctionne pas en dehors de la portée. Si vous définissez une valeur de x, DynamoDB renvoie les x premiers éléments correspondants.

La valeur LastEvaluatedKey s'applique également dans le cas de paramètres de limite donnant des résultats partiels. Utilisez-le pour effectuer des analyses.

Result Count - Les réponses aux requêtes et aux analyses incluent également des informations relatives à ScannedCountet Count, qui quantifie les articles numérisés / interrogés et quantifie les articles retournés. Si vous ne filtrez pas, leurs valeurs sont identiques. Lorsque vous dépassez 1 Mo, les décomptes ne représentent que la partie traitée.

Consistency- Les résultats des requêtes et des analyses sont finalement des lectures cohérentes, cependant, vous pouvez également définir des lectures fortement cohérentes. Utilisez leConsistentRead paramètre pour modifier ce paramètre.

Note - Des paramètres de lecture cohérents ont un impact sur la consommation en utilisant le double des unités de capacité lorsqu'ils sont définis sur fortement cohérent.

Performance- Les requêtes offrent de meilleures performances que les analyses en raison des analyses explorant la table complète ou l'index secondaire, ce qui entraîne une réponse lente et une consommation de débit élevée. Les analyses fonctionnent mieux pour les petites tables et les recherches avec moins de filtres, cependant, vous pouvez concevoir des analyses allégées en obéissant à quelques bonnes pratiques, comme éviter une activité de lecture soudaine et accélérée et exploiter des analyses parallèles.

Une requête trouve une certaine plage de clés satisfaisant à une condition donnée, les performances étant dictées par la quantité de données qu'elle récupère plutôt que par le volume de clés. Les paramètres de l'opération et le nombre de correspondances ont un impact spécifique sur les performances.

Balayage parallèle

Les opérations de numérisation exécutent le traitement de manière séquentielle par défaut. Ensuite, ils renvoient les données par portions de 1 Mo, ce qui invite l'application à récupérer la portion suivante. Cela entraîne de longues analyses pour les grandes tables et index.

Cette caractéristique signifie également que les analyses peuvent ne pas toujours exploiter pleinement le débit disponible. DynamoDB distribue les données de table sur plusieurs partitions; et le débit d'analyse reste limité à une seule partition en raison de son fonctionnement sur une seule partition.

Une solution à ce problème vient de la division logique des tables ou des index en segments. Ensuite, les «travailleurs» analysent en parallèle (simultanément) les segments. Il utilise les paramètres de Segment etTotalSegments pour spécifier les segments analysés par certains travailleurs et spécifier la quantité totale de segments traités.

Numéro de travailleur

Vous devez tester les valeurs de travail (paramètre de segment) pour obtenir les meilleures performances d'application.

Note- Les analyses parallèles avec de grands ensembles de travailleurs ont un impact sur le débit en consommant éventuellement tout le débit. Gérez ce problème avec le paramètre Limit, que vous pouvez utiliser pour empêcher un seul worker de consommer tout le débit.

Voici un exemple d'analyse approfondie.

Cet exemple utilise également Eclipse IDE, un fichier d'informations d'identification AWS et AWS Toolkit dans un projet Eclipse AWS Java.

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
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 ScanOpSample {  
   static DynamoDB dynamoDB = new DynamoDB(
      new AmazonDynamoDBClient(new ProfileCredentialsProvider())); 
   static String tableName = "ProductList";  
   
   public static void main(String[] args) throws Exception { 
      findProductsUnderOneHun();                       //finds products under 100 dollars
   }  
   private static void findProductsUnderOneHun() { 
      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, Nomenclature, ProductCategory, Price",     //ProjectionExpression 
         null,                                           //No ExpressionAttributeNames  
         expressionAttributeValues);
         
      System.out.println("Scanned " + tableName + " to find items under $100."); 
      Iterator<Item> iterator = items.iterator(); 
         
      while (iterator.hasNext()) { 
         System.out.println(iterator.next().toJSONPretty()); 
      }     
   } 
}

DynamoDB utilise des index pour les attributs de clé primaire afin d'améliorer les accès. Ils accélèrent les accès aux applications et la récupération des données, et prennent en charge de meilleures performances en réduisant le retard des applications.

Index secondaire

Un index secondaire contient un sous-ensemble d'attributs et une clé alternative. Vous l'utilisez via une opération de requête ou d'analyse, qui cible l'index.

Son contenu comprend les attributs que vous projetez ou copiez. Lors de la création, vous définissez une clé alternative pour l'index et tous les attributs que vous souhaitez projeter dans l'index. DynamoDB effectue ensuite une copie des attributs dans l'index, y compris les attributs de clé primaire provenant de la table. Après avoir effectué ces tâches, vous utilisez simplement une requête / analyse comme si vous exécutiez sur une table.

DynamoDB gère automatiquement tous les index secondaires. Sur les opérations d'élément, telles que l'ajout ou la suppression, il met à jour tous les index de la table cible.

DynamoDB propose deux types d'index secondaires -

Global Secondary Index- Cet index comprend une clé de partition et une clé de tri, qui peuvent différer de la table source. Il utilise le libellé «global» en raison de la capacité des requêtes / analyses sur l'index à couvrir toutes les données de la table et toutes les partitions.
Local Secondary Index- Cet index partage une clé de partition avec la table, mais utilise une clé de tri différente. Sa nature «locale» résulte de la portée de toutes ses partitions vers une partition de table avec une valeur de clé de partition identique.

Le meilleur type d'index à utiliser dépend des besoins de l'application. Considérez les différences entre les deux présentées dans le tableau suivant -

Qualité	Indice secondaire mondial	Index secondaire local
Schéma clé	Il utilise une clé primaire simple ou composite.	Il utilise toujours une clé primaire composite.
Attributs clés	La clé de partition d'index et la clé de tri peuvent être constituées d'attributs de table de type chaîne, nombre ou binaire.	La clé de partition de l'index est un attribut partagé avec la clé de partition de table. La clé de tri peut être une chaîne, un nombre ou des attributs de table binaire.
Limites de taille par valeur de clé de partition	Ils ne comportent aucune limitation de taille.	Il impose une limite maximale de 10 Go sur la taille totale des éléments indexés associés à une valeur de clé de partition.
Opérations d'index en ligne	Vous pouvez les générer lors de la création de la table, les ajouter à des tables existantes ou supprimer celles existantes.	Vous devez les créer lors de la création de la table, mais vous ne pouvez pas les supprimer ni les ajouter aux tables existantes.
Requêtes	Il permet des requêtes couvrant toute la table et chaque partition.	Ils adressent des partitions uniques via la valeur de clé de partition fournie dans la requête.
Cohérence	Les requêtes de ces index n'offrent que l'option finalement cohérente.	Les requêtes de ces derniers offrent les options de cohérence à terme ou fortement cohérente.
Coût de débit	Il inclut les paramètres de débit pour les lectures et les écritures. Les requêtes / analyses consomment de la capacité de l'index, pas de la table, ce qui s'applique également aux mises à jour d'écriture de table.	Les requêtes / analyses consomment la capacité de lecture de la table. Table écrit les index locaux de mise à jour et consomme des unités de capacité de table.
Projection	Les requêtes / analyses ne peuvent demander que des attributs projetés dans l'index, sans récupération des attributs de table.	Les requêtes / analyses peuvent demander ces attributs non projetés; en outre, des récupérations automatiques d'entre eux se produisent.

Lorsque vous créez plusieurs tables avec des index secondaires, faites-le de manière séquentielle; ce qui signifie créer une table et attendre qu'elle atteigne l'état ACTIF avant d'en créer une autre et d'attendre à nouveau. DynamoDB n'autorise pas la création simultanée.

Chaque index secondaire nécessite certaines spécifications -

Type - Spécifiez local ou global.
Name - Il utilise des règles de dénomination identiques aux tables.
Key Schema - Seules les chaînes, les nombres ou les types binaires de niveau supérieur sont autorisés, le type d'index déterminant d'autres exigences.
Attributes for Projection - DynamoDB les projette automatiquement et autorise tout type de données.
Throughput - Spécifiez la capacité de lecture / écriture pour les index secondaires globaux.

La limite des index reste 5 globale et 5 locale par table.

Vous pouvez accéder aux informations détaillées sur les index avec DescribeTable. Il renvoie le nom, la taille et le nombre d'éléments.

Note - Ces valeurs sont mises à jour toutes les 6 heures.

Dans les requêtes ou analyses utilisées pour accéder aux données d'index, indiquez les noms de table et d'index, les attributs souhaités pour le résultat et toutes les instructions conditionnelles. DynamoDB offre la possibilité de renvoyer les résultats par ordre croissant ou décroissant.

Note - La suppression d'une table supprime également tous les index.

Les applications nécessitant différents types de requêtes avec des attributs différents peuvent utiliser un ou plusieurs index secondaires globaux pour exécuter ces requêtes détaillées.

For example - Un système gardant une trace des utilisateurs, de leur statut de connexion et de leur temps de connexion. La croissance de l'exemple précédent ralentit les requêtes sur ses données.

Les index secondaires globaux accélèrent les requêtes en organisant une sélection d'attributs à partir d'une table. Ils utilisent des clés primaires pour trier les données et ne nécessitent aucun attribut de table de clé, ni schéma de clé identique à la table.

Tous les index secondaires globaux doivent inclure une clé de partition, avec l'option d'une clé de tri. Le schéma de clé d'index peut différer de la table et les attributs de clé d'index peuvent utiliser n'importe quelle chaîne, nombre ou attribut de table binaire de niveau supérieur.

Dans une projection, vous pouvez utiliser d'autres attributs de table, mais les requêtes ne sont pas extraites des tables parentes.

Projections d'attributs

Les projections consistent en un jeu d'attributs copié de la table vers l'index secondaire. Une projection se produit toujours avec la clé de partition de table et la clé de tri. Dans les requêtes, les projections permettent à DynamoDB d'accéder à n'importe quel attribut de la projection; ils existent essentiellement comme leur propre table.

Dans une création d'index secondaire, vous devez spécifier des attributs pour la projection. DynamoDB propose trois méthodes pour effectuer cette tâche -

KEYS_ONLY- Tous les éléments d'index se composent de la partition de table, des valeurs de clé de tri et des valeurs de clé d'index. Cela crée le plus petit index.
INCLUDE - Il comprend les attributs KEYS_ONLY et les attributs non clés spécifiés.
ALL - Il inclut tous les attributs de la table source, créant ainsi le plus grand index possible.

Notez les compromis dans la projection d'attributs dans un index secondaire global, qui sont liés au débit et au coût de stockage.

Considérez les points suivants -

Si vous n'avez besoin que d'accéder à quelques attributs, avec une faible latence, projetez uniquement ceux dont vous avez besoin. Cela réduit les coûts de stockage et d'écriture.
Si une application accède fréquemment à certains attributs non clés, projetez-les car les coûts de stockage sont pâles par rapport à la consommation d'analyse.
Vous pouvez projeter de grands ensembles d'attributs fréquemment utilisés, mais cela entraîne un coût de stockage élevé.
Utilisez KEYS_ONLY pour les requêtes de table peu fréquentes et les écritures / mises à jour fréquentes. Cela contrôle la taille, mais offre toujours de bonnes performances sur les requêtes.

Requêtes et analyses d'index secondaire global

Vous pouvez utiliser des requêtes pour accéder à un ou plusieurs éléments dans un index. Vous devez spécifier le nom de l'index et de la table, les attributs souhaités et les conditions; avec la possibilité de renvoyer les résultats par ordre croissant ou décroissant.

Vous pouvez également utiliser des analyses pour obtenir toutes les données d'index. Il nécessite un nom de table et d'index. Vous utilisez une expression de filtre pour récupérer des données spécifiques.

Synchronisation des données de table et d'index

DynamoDB effectue automatiquement la synchronisation des index avec leur table parent. Chaque opération de modification sur les éléments entraîne des mises à jour asynchrones, cependant, les applications n'écrivent pas directement dans les index.

Vous devez comprendre l'impact de la maintenance DynamoDB sur les index. Lors de la création d'un index, vous spécifiez des attributs clés et des types de données, ce qui signifie que lors d'une écriture, ces types de données doivent correspondre aux types de données de schéma clés.

Lors de la création ou de la suppression d'un élément, les index sont mis à jour de manière cohérente, cependant, les mises à jour des données se propagent en une fraction de seconde (à moins qu'une défaillance du système d'un certain type ne se produise). Vous devez tenir compte de ce retard dans les candidatures.

Throughput Considerations in Global Secondary Indexes- Plusieurs index secondaires globaux ont un impact sur le débit. La création d'index nécessite des spécifications d'unité de capacité, qui existent séparément de la table, ce qui entraîne des opérations consommant des unités de capacité d'index plutôt que des unités de table.

Cela peut entraîner une limitation si une requête ou une écriture dépasse le débit provisionné. Afficher les paramètres de débit en utilisantDescribeTable.

Read Capacity- Les index secondaires globaux offrent une cohérence éventuelle. Dans les requêtes, DynamoDB effectue des calculs de provision identiques à ceux utilisés pour les tables, avec une seule différence d'utiliser la taille de l'entrée d'index plutôt que la taille de l'élément. La limite des retours de requête reste 1 Mo, ce qui inclut la taille du nom d'attribut et les valeurs de chaque élément retourné.

Capacité d'écriture

Lorsque des opérations d'écriture se produisent, l'index affecté consomme des unités d'écriture. Les coûts de débit d'écriture sont la somme des unités de capacité d'écriture consommées dans les écritures de table et des unités consommées dans les mises à jour d'index. Une opération d'écriture réussie nécessite une capacité suffisante ou entraîne une limitation.

Les coûts d'écriture restent également dépendants de certains facteurs, dont certains sont les suivants:

Les nouveaux éléments définissant des attributs indexés ou des mises à jour d'éléments définissant des attributs indexés non définis utilisent une seule opération d'écriture pour ajouter l'élément à l'index.
Les mises à jour modifiant la valeur d'attribut de clé indexée utilisent deux écritures pour supprimer un élément et en écrire un nouveau.
Une écriture de table déclenchant la suppression d'un attribut indexé utilise une seule écriture pour effacer l'ancienne projection d'élément dans l'index.
Les éléments absents de l'index avant et après une opération de mise à jour n'utilisent aucune écriture.
Les mises à jour ne modifiant que la valeur d'attribut projetée dans le schéma de clé d'index, et non la valeur d'attribut de clé indexée, utilisent une écriture pour mettre à jour les valeurs des attributs projetés dans l'index.

Tous ces facteurs supposent une taille d'élément inférieure ou égale à 1 Ko.

Stockage d'index secondaire global

Lors de l'écriture d'un élément, DynamoDB copie automatiquement le bon ensemble d'attributs dans tous les index où les attributs doivent exister. Cela a un impact sur votre compte en le facturant pour le stockage des éléments de table et le stockage des attributs. L'espace utilisé résulte de la somme de ces quantités -

Taille d'octet de la clé primaire de la table
Taille d'octet de l'attribut de clé d'index
Taille en octets des attributs projetés
100 octets de surcharge par élément d'index

Vous pouvez estimer les besoins de stockage en estimant la taille moyenne des éléments et en multipliant par la quantité des éléments de table avec les attributs de clé d'index secondaire global.

DynamoDB n'écrit pas de données d'élément pour un élément de table avec un attribut non défini défini comme une partition d'index ou une clé de tri.

Global Secondary Index Crud

Créez une table avec des index secondaires globaux à l'aide du CreateTable opération associée au GlobalSecondaryIndexesparamètre. Vous devez spécifier un attribut qui servira de clé de partition d'index ou en utiliser un autre pour la clé de tri d'index. Tous les attributs de clé d'index doivent être des chaînes, des nombres ou des scalaires binaires. Vous devez également fournir des paramètres de débit, comprenantReadCapacityUnits et WriteCapacityUnits.

Utilisation UpdateTable pour ajouter à nouveau des index secondaires globaux aux tables existantes à l'aide du paramètre GlobalSecondaryIndexes.

Dans cette opération, vous devez fournir les entrées suivantes -

Nom de l'index
Schéma clé
Attributs projetés
Paramètres de débit

L'ajout d'un index secondaire global peut prendre beaucoup de temps avec des tables volumineuses en raison du volume d'éléments, du volume d'attributs projeté, de la capacité d'écriture et de l'activité d'écriture. UtilisationCloudWatch métriques pour surveiller le processus.

Utilisation DescribeTablepour récupérer les informations d'état d'un index secondaire global. Il renvoie l'un des quatreIndexStatus pour les GlobalSecondaryIndexes -

CREATING - Il indique la phase de construction de l'index et son indisponibilité.
ACTIVE - Il indique que l'index est prêt à être utilisé.
UPDATING - Il indique l'état de mise à jour des paramètres de débit.
DELETING - Il indique le statut de suppression de l'index, et son indisponibilité permanente pour l'utilisation.

Mettez à jour les paramètres de débit provisionné de l'index secondaire global pendant la phase de chargement / remplissage (DynamoDB écrivant des attributs dans un index et suivant les éléments ajoutés / supprimés / mis à jour). UtilisationUpdateTable pour effectuer cette opération.

N'oubliez pas que vous ne pouvez pas ajouter / supprimer d'autres index pendant la phase de remblayage.

Utilisez UpdateTable pour supprimer les index secondaires globaux. Il permet la suppression d'un seul index par opération, mais vous pouvez exécuter plusieurs opérations simultanément, jusqu'à cinq. Le processus de suppression n'affecte pas les activités de lecture / écriture de la table parent, mais vous ne pouvez pas ajouter / supprimer d'autres index tant que l'opération n'est pas terminée.

Utilisation de Java pour travailler avec des index secondaires globaux

Créez une table avec un index via CreateTable. Créez simplement une instance de classe DynamoDB, unCreateTableRequest classe pour les informations de demande et transmettez l'objet de demande à la méthode CreateTable.

Le programme suivant est un court exemple -

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient ( 
   new ProfileCredentialsProvider()));
   
// Attributes 
ArrayList<AttributeDefinition> attributeDefinitions = new 
   ArrayList<AttributeDefinition>();  
attributeDefinitions.add(new AttributeDefinition() 
   .withAttributeName("City") 
   .withAttributeType("S"));
   
attributeDefinitions.add(new AttributeDefinition() 
   .withAttributeName("Date") 
   .withAttributeType("S"));
   
attributeDefinitions.add(new AttributeDefinition() 
   .withAttributeName("Wind") 
   .withAttributeType("N"));
   
// Key schema of the table 
ArrayList<KeySchemaElement> tableKeySchema = new ArrayList<KeySchemaElement>(); 
tableKeySchema.add(new KeySchemaElement()
   .withAttributeName("City") 
   .withKeyType(KeyType.HASH));              //Partition key
   
tableKeySchema.add(new KeySchemaElement() 
   .withAttributeName("Date") 
   .withKeyType(KeyType.RANGE));             //Sort key
   
// Wind index 
GlobalSecondaryIndex windIndex = new GlobalSecondaryIndex() 
   .withIndexName("WindIndex") 
   .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("Wind") 
   .withKeyType(KeyType.RANGE));             //Sort key
   
windIndex.setKeySchema(indexKeySchema);  
CreateTableRequest createTableRequest = new CreateTableRequest() 
   .withTableName("ClimateInfo") 
   .withProvisionedThroughput(new ProvisionedThroughput() 
   .withReadCapacityUnits((long) 5) 
   .withWriteCapacityUnits((long) 1))
   .withAttributeDefinitions(attributeDefinitions) 
   .withKeySchema(tableKeySchema) 
   .withGlobalSecondaryIndexes(windIndex); 
Table table = dynamoDB.createTable(createTableRequest); 
System.out.println(table.getDescription());

Récupérez les informations d'index avec DescribeTable. Tout d'abord, créez une instance de classe DynamoDB. Créez ensuite une instance de classe Table pour cibler un index. Enfin, passez le tableau à la méthode describe.

Voici un petit exemple -

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient ( 
   new ProfileCredentialsProvider()));
   
Table table = dynamoDB.getTable("ClimateInfo"); 
TableDescription tableDesc = table.describe();  
Iterator<GlobalSecondaryIndexDescription> gsiIter = 
   tableDesc.getGlobalSecondaryIndexes().iterator(); 

while (gsiIter.hasNext()) { 
   GlobalSecondaryIndexDescription gsiDesc = gsiIter.next(); 
   System.out.println("Index data " + gsiDesc.getIndexName() + ":");  
   Iterator<KeySchemaElement> kse7Iter = 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("\tProjection type: " + projection.getProjectionType()); 
   
   if (projection.getProjectionType().toString().equals("INCLUDE")) { 
      System.out.println("\t\tNon-key projected attributes: " 
         + projection.getNonKeyAttributes()); 
   } 
}

Utilisez Query pour effectuer une requête d'index comme avec une requête de table. Créez simplement une instance de classe DynamoDB, une instance de classe Table pour l'index cible, une instance de classe Index pour l'index spécifique et transmettez l'index et l'objet de requête à la méthode de requête.

Jetez un œil au code suivant pour mieux comprendre -

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient ( 
   new ProfileCredentialsProvider()));
   
Table table = dynamoDB.getTable("ClimateInfo"); 
Index index = table.getIndex("WindIndex");  
QuerySpec spec = new QuerySpec() 
   .withKeyConditionExpression("#d = :v_date and Wind = :v_wind") 
   .withNameMap(new NameMap() 
   .with("#d", "Date"))
   .withValueMap(new ValueMap() 
   .withString(":v_date","2016-05-15") 
   .withNumber(":v_wind",0));
   
ItemCollection<QueryOutcome> items = index.query(spec);
Iterator<Item> iter = items.iterator();

while (iter.hasNext()) {
   System.out.println(iter.next().toJSONPretty()); 
}

Le programme suivant est un plus grand exemple pour une meilleure compréhension -

Cet exemple utilise également Eclipse IDE, un fichier d'informations d'identification AWS et AWS Toolkit dans un projet Eclipse AWS Java.

import java.util.ArrayList;
import java.util.Iterator;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
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 GlobalSecondaryIndexSample {  
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient ( 
      new ProfileCredentialsProvider()));  
   public static String tableName = "Bugs";   
   public static void main(String[] args) throws Exception {  
      createTable(); 
      queryIndex("CreationDateIndex"); 
      queryIndex("NameIndex"); 
      queryIndex("DueDateIndex"); 
   }
   public static void createTable() {  
      // Attributes 
      ArrayList<AttributeDefinition> attributeDefinitions = new 
         ArrayList<AttributeDefinition>();  
      attributeDefinitions.add(new AttributeDefinition()
         .withAttributeName("BugID") 
         .withAttributeType("S")); 
         
      attributeDefinitions.add(new AttributeDefinition() 
         .withAttributeName("Name")
         .withAttributeType("S"));
         
      attributeDefinitions.add(new AttributeDefinition() 
         .withAttributeName("CreationDate")
         .withAttributeType("S"));
         
      attributeDefinitions.add(new AttributeDefinition() 
         .withAttributeName("DueDate") 
         .withAttributeType("S"));
         
      // Table Key schema
      ArrayList<KeySchemaElement> tableKeySchema = new ArrayList<KeySchemaElement>(); 
      tableKeySchema.add (new KeySchemaElement() 
         .withAttributeName("BugID") 
         .withKeyType(KeyType.HASH));              //Partition key 
      
      tableKeySchema.add (new KeySchemaElement() 
         .withAttributeName("Name") 
         .withKeyType(KeyType.RANGE));             //Sort key
         
      // Indexes' initial provisioned throughput
      ProvisionedThroughput ptIndex = new ProvisionedThroughput()
         .withReadCapacityUnits(1L)
         .withWriteCapacityUnits(1L);
         
      // CreationDateIndex 
      GlobalSecondaryIndex creationDateIndex = new GlobalSecondaryIndex() 
         .withIndexName("CreationDateIndex") 
         .withProvisionedThroughput(ptIndex) 
         .withKeySchema(new KeySchemaElement() 
         .withAttributeName("CreationDate") 
         .withKeyType(KeyType.HASH),               //Partition key 
         new KeySchemaElement()
         .withAttributeName("BugID") 
         .withKeyType(KeyType.RANGE))              //Sort key 
         .withProjection(new Projection() 
         .withProjectionType("INCLUDE") 
         .withNonKeyAttributes("Description", "Status"));
         
      // NameIndex 
      GlobalSecondaryIndex nameIndex = new GlobalSecondaryIndex() 
         .withIndexName("NameIndex") 
         .withProvisionedThroughput(ptIndex) 
         .withKeySchema(new KeySchemaElement()  
         .withAttributeName("Name")  
         .withKeyType(KeyType.HASH),                  //Partition key 
         new KeySchemaElement()  
         .withAttributeName("BugID")  
         .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)) 
         .withAttributeDefinitions(attributeDefinitions)
         .withKeySchema(tableKeySchema)
         .withGlobalSecondaryIndexes(creationDateIndex, nameIndex, dueDateIndex);  
         System.out.println("Creating " + tableName + "..."); 
         dynamoDB.createTable(createTableRequest);  
      
      // Pause for active table state 
      System.out.println("Waiting for ACTIVE state of " + tableName); 
      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 == "CreationDateIndex") { 
         System.out.println("Issues filed on 2016-05-22"); 
         querySpec.withKeyConditionExpression("CreationDate = :v_date and begins_with
            (BugID, :v_bug)") 
            .withValueMap(new ValueMap() 
            .withString(":v_date","2016-05-22")
            .withString(":v_bug","A-")); 
         items = index.query(querySpec); 
      } else if (indexName == "NameIndex") { 
         System.out.println("Compile error"); 
         querySpec.withKeyConditionExpression("Name = :v_name and begins_with
            (BugID, :v_bug)") 
            .withValueMap(new ValueMap() 
            .withString(":v_name","Compile error") 
            .withString(":v_bug","A-")); 
         items = index.query(querySpec); 
      } else if (indexName == "DueDateIndex") { 
         System.out.println("Items due on 2016-10-15"); 
         querySpec.withKeyConditionExpression("DueDate = :v_date") 
         .withValueMap(new ValueMap() 
         .withString(":v_date","2016-10-15")); 
         items = index.query(querySpec); 
      } else { 
         System.out.println("\nInvalid index name"); 
         return; 
      }  
      Iterator<Item> iterator = items.iterator(); 
      System.out.println("Query: getting result..."); 
      
      while (iterator.hasNext()) { 
         System.out.println(iterator.next().toJSONPretty()); 
      } 
   } 
}

Certaines applications n'effectuent des requêtes qu'avec la clé primaire, mais certaines situations bénéficient d'une autre clé de tri. Donnez à votre application un choix en créant un ou plusieurs index secondaires locaux.

Des exigences d'accès aux données complexes, telles que le peignage de millions d'éléments, rendent nécessaire d'effectuer des requêtes / analyses plus efficaces. Les index secondaires locaux fournissent une clé de tri alternative pour une valeur de clé de partition. Ils contiennent également des copies de tout ou partie des attributs de table. Ils organisent les données par clé de partition de table, mais utilisent une clé de tri différente.

L'utilisation d'un index secondaire local supprime la nécessité d'une analyse complète de la table et permet une requête simple et rapide à l'aide d'une clé de tri.

Tous les index secondaires locaux doivent satisfaire certaines conditions -

Clé de partition et clé de partition de table source identiques.
Une clé de tri d'un seul attribut scalaire.
Projection de la clé de tri de la table source agissant comme un attribut non clé.

Tous les index secondaires locaux contiennent automatiquement les clés de partition et de tri des tables parentes. Dans les requêtes, cela signifie une collecte efficace des attributs projetés, ainsi que la récupération des attributs non projetés.

La limite de stockage pour un index secondaire local reste de 10 Go par valeur de clé de partition, qui comprend tous les éléments de table et les éléments d'index partageant une valeur de clé de partition.

Projeter un attribut

Certaines opérations nécessitent des lectures / extractions excessives en raison de leur complexité. Ces opérations peuvent consommer un débit important. La projection vous permet d'éviter une récupération coûteuse et d'effectuer des requêtes riches en isolant ces attributs. N'oubliez pas que les projections consistent en des attributs copiés dans un index secondaire.

Lors de la création d'un index secondaire, vous spécifiez les attributs projetés. Rappelez-vous les trois options fournies par DynamoDB:KEYS_ONLY, INCLUDE, and ALL.

Lorsque vous optez pour certains attributs dans la projection, tenez compte des compromis de coût associés -

Si vous ne projetez qu'un petit ensemble d'attributs nécessaires, vous réduisez considérablement les coûts de stockage.
Si vous projetez des attributs non clés fréquemment utilisés, vous compensez les coûts d'analyse par les coûts de stockage.
Si vous projetez la plupart ou tous les attributs non clés, cela maximise la flexibilité et réduit le débit (pas de récupération); cependant, les coûts de stockage augmentent.
Si vous projetez KEYS_ONLY pour les écritures / mises à jour fréquentes et les requêtes peu fréquentes, cela minimise la taille, mais maintient la préparation des requêtes.

Création d'index secondaire local

Utilisez le LocalSecondaryIndexparamètre de CreateTable pour créer un ou plusieurs index secondaires locaux. Vous devez spécifier un attribut non clé pour la clé de tri. Lors de la création de table, vous créez des index secondaires locaux. Lors de la suppression, vous supprimez ces index.

Les tables avec un index secondaire local doivent obéir à une limite de 10 Go de taille par valeur de clé de partition, mais peuvent stocker n'importe quelle quantité d'éléments.

Requêtes et analyses d'index secondaire local

Une opération de requête sur les index secondaires locaux renvoie tous les éléments avec une valeur de clé de partition correspondante lorsque plusieurs éléments de l'index partagent les valeurs de clé de tri. Les articles correspondants ne reviennent pas dans un certain ordre. Les requêtes pour les index secondaires locaux utilisent une cohérence éventuelle ou forte, avec des lectures fortement cohérentes fournissant les dernières valeurs.

Une opération d'analyse renvoie toutes les données d'index secondaires locales. Les analyses nécessitent que vous fournissiez un nom de table et d'index et que vous autorisiez l'utilisation d'une expression de filtre pour supprimer les données.

Rédaction d'articles

Lors de la création d'un index secondaire local, vous spécifiez un attribut de clé de tri et son type de données. Lorsque vous écrivez un élément, son type doit correspondre au type de données du schéma de clé si l'élément définit un attribut d'une clé d'index.

DynamoDB n'impose aucune exigence de relation un à un sur les éléments de table et les éléments d'index secondaire local. Les tables avec plusieurs index secondaires locaux supportent des coûts d'écriture plus élevés que celles avec moins.

Considérations relatives au débit dans les index secondaires locaux

La consommation de capacité de lecture d'une requête dépend de la nature de l'accès aux données. Les requêtes utilisent une cohérence éventuelle ou forte, avec des lectures fortement cohérentes utilisant une unité contre une demi-unité dans des lectures finalement cohérentes.

Les limitations de résultats incluent une taille maximale de 1 Mo. Les tailles de résultat proviennent de la somme de la taille d'élément d'index correspondante arrondie au 4 Ko le plus proche, et de la taille d'élément de table correspondante également arrondie au 4 Ko le plus proche.

La consommation de capacité d'écriture reste dans les unités provisionnées. Calculez le coût total provisionné en trouvant la somme des unités consommées dans l'écriture de table et des unités consommées lors de la mise à jour des index.

Vous pouvez également tenir compte des facteurs clés influençant le coût, dont certains peuvent être -

Lorsque vous écrivez un élément définissant un attribut indexé ou mettez à jour un élément pour définir un attribut indexé non défini, une seule opération d'écriture se produit.
Lorsqu'une mise à jour de table modifie une valeur d'attribut de clé indexée, deux écritures se produisent pour supprimer puis - ajouter un élément.
Lorsqu'une écriture entraîne la suppression d'un attribut indexé, une écriture se produit pour supprimer l'ancienne projection d'élément.
Lorsqu'un élément n'existe pas dans l'index avant ou après une mise à jour, aucune écriture n'a lieu.

Stockage d'index secondaire local

Lors d'une écriture d'élément de table, DynamoDB copie automatiquement le bon jeu d'attributs dans les index secondaires locaux requis. Cela charge votre compte. L'espace utilisé résulte de la somme de la taille d'octet de clé primaire de table, de la taille d'octet d'attribut de clé d'index, de toute taille d'octet d'attribut projetée actuelle et de 100 octets de surcharge pour chaque élément d'index.

Le stockage estimé est obtenu en estimant la taille d'élément d'index moyenne et en multipliant par la quantité d'élément de table.

Utilisation de Java pour travailler avec des index secondaires locaux

Créez un index secondaire local en créant d'abord une instance de classe DynamoDB. Ensuite, créez une instance de classe CreateTableRequest avec les informations de demande nécessaires. Enfin, utilisez la méthode createTable.

Exemple

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
   new ProfileCredentialsProvider()));
String tableName = "Tools";  
CreateTableRequest createTableRequest = new 
   CreateTableRequest().withTableName(tableName);
   
//Provisioned Throughput
createTableRequest.setProvisionedThroughput (
   new ProvisionedThroughput()
   .withReadCapacityUnits((long)5)
   .withWriteCapacityUnits(( long)5));
   
//Attributes 
ArrayList<AttributeDefinition> attributeDefinitions = 
   new ArrayList<AttributeDefinition>();
   attributeDefinitions.add(new AttributeDefinition()
   .withAttributeName("Make")
   .withAttributeType("S"));
   
attributeDefinitions.add(new AttributeDefinition()
   .withAttributeName("Model")
   .withAttributeType("S"));
   
attributeDefinitions.add(new AttributeDefinition()
   .withAttributeName("Line")
   .withAttributeType("S"));
   
createTableRequest.setAttributeDefinitions(attributeDefinitions);

//Key Schema 
ArrayList<KeySchemaElement> tableKeySchema = new 
   ArrayList<KeySchemaElement>();
   
tableKeySchema.add(new KeySchemaElement()
   .withAttributeName("Make")
   .withKeyType(KeyType.HASH));                    //Partition key
   
tableKeySchema.add(new KeySchemaElement()
   .withAttributeName("Model")
   .withKeyType(KeyType.RANGE));                   //Sort key
   
createTableRequest.setKeySchema(tableKeySchema);
ArrayList<KeySchemaElement> indexKeySchema = new 
   ArrayList<KeySchemaElement>();
   
indexKeySchema.add(new KeySchemaElement()
   .withAttributeName("Make")
   .withKeyType(KeyType.HASH));                   //Partition key
   
indexKeySchema.add(new KeySchemaElement()
   .withAttributeName("Line")
   .withKeyType(KeyType.RANGE));                   //Sort key
   
Projection projection = new Projection()
   .withProjectionType(ProjectionType.INCLUDE);

ArrayList<String> nonKeyAttributes = new ArrayList<String>(); 
nonKeyAttributes.add("Type"); 
nonKeyAttributes.add("Year"); 
projection.setNonKeyAttributes(nonKeyAttributes);  

LocalSecondaryIndex localSecondaryIndex = new LocalSecondaryIndex() 
   .withIndexName("ModelIndex")
   .withKeySchema(indexKeySchema)
   .withProjection(p rojection);  

ArrayList<LocalSecondaryIndex> localSecondaryIndexes = new 
   ArrayList<LocalSecondaryIndex>(); 

localSecondaryIndexes.add(localSecondaryIndex); 
createTableRequest.setLocalSecondaryIndexes(localSecondaryIndexes);  
Table table = dynamoDB.createTable(createTableRequest); 
System.out.println(table.getDescription());

Récupérez des informations sur un index secondaire local avec la méthode describe. Créez simplement une instance de classe DynamoDB, créez une instance de classe Table et transmettez la table à la méthode describe.

Exemple

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
   new ProfileCredentialsProvider()));
   
String tableName = "Tools";
Table table = dynamoDB.getTable(tableName);
TableDescription tableDescription = table.describe();

List<LocalSecondaryIndexDescription> localSecondaryIndexes = 
   tableDescription.getLocalSecondaryIndexes();
   
Iterator<LocalSecondaryIndexDescription> lsiIter = 
   localSecondaryIndexes.iterator();
   
while (lsiIter.hasNext()) {  
   LocalSecondaryIndexDescription lsiDescription = lsiIter.next(); 
   System.out.println("Index info " + 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("\tProjection type: " + projection.getProjectionType()); 
   
   if (projection.getProjectionType().toString().equals("INCLUDE")) { 
      System.out.println("\t\tNon-key projected attributes: " + 
         projection.getNonKeyAttributes()); 
   } 
}

Exécutez une requête en utilisant les mêmes étapes qu'une requête de table. Créez simplement une instance de classe DynamoDB, une instance de classe Table, une instance de classe Index, un objet de requête et utilisez la méthode de requête.

Exemple

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
   new ProfileCredentialsProvider()));
   
String tableName = "Tools";  
Table table = dynamoDB.getTable(tableName); 
Index index = table.getIndex("LineIndex");  
QuerySpec spec = new QuerySpec() 
   .withKeyConditionExpression("Make = :v_make and Line = :v_line") 
   .withValueMap(new ValueMap() 
   .withString(":v_make", "Depault") 
   .withString(":v_line", "SuperSawz"));
      
ItemCollection<QueryOutcome> items = index.query(spec);
Iterator<Item> itemsIter = items.iterator();

while (itemsIter.hasNext()) { 
   Item item = itemsIter.next(); 
   System.out.println(item.toJSONPretty()); 
}

Vous pouvez également consulter l'exemple suivant.

L'exemple suivant utilise également Eclipse IDE, un fichier d'informations d'identification AWS et AWS Toolkit dans un projet Eclipse AWS Java.

Exemple

import java.util.ArrayList;
import java.util.Iterator;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;

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 LocalSecondaryIndexSample {  
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
      new ProfileCredentialsProvider()));  
   public static String tableName = "ProductOrders";  
   
   public static void main(String[] args) throws Exception {  
      createTable();
      query(null); 
      query("IsOpenIndex"); 
      query("OrderCreationDateIndex"); 
   }
   public static void createTable() { 
      CreateTableRequest createTableRequest = new CreateTableRequest() 
         .withTableName(tableName) 
         .withProvisionedThroughput(new ProvisionedThroughput() 
         .withReadCapacityUnits((long) 1) 
         .withWriteCapacityUnits((long) 1));
         
      // Table partition and sort keys attributes 
      ArrayList<AttributeDefinition> attributeDefinitions = new 
         ArrayList<AttributeDefinition>(); 
      
      attributeDefinitions.add(new AttributeDefinition() 
         .withAttributeName("CustomerID") 
         .withAttributeType("S"));
         
      attributeDefinitions.add(new AttributeDefinition() 
         .withAttributeName("OrderID") 
         .withAttributeType("N"));
         
      // Index primary key attributes 
      attributeDefinitions.add(new AttributeDefinition() 
         .withAttributeName("OrderDate") 
         .withAttributeType("N"));
         
      attributeDefinitions.add(new AttributeDefinition() 
         .withAttributeName("OpenStatus") 
         .withAttributeType("N"));  
      createTableRequest.setAttributeDefinitions(attributeDefinitions);
      
      // Table key schema 
      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>();  
      
      // OrderDateIndex 
      LocalSecondaryIndex orderDateIndex = new LocalSecondaryIndex() 
         .withIndexName("OrderDateIndex");
         
      // OrderDateIndex key schema 
      ArrayList<KeySchemaElement> indexKeySchema = new 
         ArrayList<KeySchemaElement>(); 
      indexKeySchema.add(new KeySchemaElement() 
         .withAttributeName("CustomerID") 
         .withKeyType(KeyType.HASH));                   //Partition key
         
      indexKeySchema.add(new KeySchemaElement() 
         .withAttributeName("OrderDate") 
         .withKeyType(KeyType.RANGE));                   //Sort key
      orderDateIndex.setKeySchema(indexKeySchema);
      
      // OrderCreationDateIndex projection w/attributes list 
      Projection projection = new Projection() 
         .withProjectionType(ProjectionType.INCLUDE); 
      
      ArrayList<String> nonKeyAttributes = new ArrayList<String>(); 
      nonKeyAttributes.add("ProdCat"); 
      nonKeyAttributes.add("ProdNomenclature"); 
      projection.setNonKeyAttributes(nonKeyAttributes);
      orderCreationDateIndex.setProjection(projection);  
      localSecondaryIndexes.add(orderDateIndex);  
      
      // IsOpenIndex 
      LocalSecondaryIndex isOpenIndex = new LocalSecondaryIndex() 
         .withIndexName("IsOpenIndex");  
      
      // OpenStatusIndex key schema 
      indexKeySchema = new ArrayList<KeySchemaElement>(); 
      indexKeySchema.add(new KeySchemaElement() 
         .withAttributeName("CustomerID") 
         .withKeyType(KeyType.HASH));                   //Partition key
         
      indexKeySchema.add(new KeySchemaElement() 
         .withAttributeName("OpenStatus") 
         .withKeyType(KeyType.RANGE));                   //Sort key
         
      // OpenStatusIndex projection 
      projection = new Projection() .withProjectionType(ProjectionType.ALL);  
      OpenStatusIndex.setKeySchema(indexKeySchema); 
      OpenStatusIndex.setProjection(projection);  
      localSecondaryIndexes.add(OpenStatusIndex);  
      
      // Put definitions in CreateTable request 
      createTableRequest.setLocalSecondaryIndexes(localSecondaryIndexes);  
      System.out.println("Spawning table " + tableName + "..."); 
      System.out.println(dynamoDB.createTable(createTableRequest));  
      
      // Pause for ACTIVE status 
      System.out.println("Waiting for ACTIVE table:" + tableName); 
      try { 
         Table table = dynamoDB.getTable(tableName);
         table.waitForActive(); 
      } catch (InterruptedException e) { 
         e.printStackTrace(); 
      } 
   }
   public static void query(String indexName) {  
      Table table = dynamoDB.getTable(tableName);  
      System.out.println("\n*************************************************\n"); 
      System.out.println("Executing query on" + tableName);  
      QuerySpec querySpec = new QuerySpec() 
         .withConsistentRead(true) 
         .withScanIndexForward(true) 
         .withReturnConsumedCapacity(ReturnConsumedCapacity.TOTAL);
      
      if (indexName == "OpenStatusIndex") {  
         System.out.println("\nEmploying index: '" + indexName 
            + "' open orders for this customer.");
            
         System.out.println( 
            "Returns only user-specified attribute list\n"); 
         Index index = table.getIndex(indexName); 
             
         querySpec.withKeyConditionExpression("CustomerID = :v_custmid and 
            OpenStatus = :v_openstat") 
            .withValueMap(new ValueMap() 
            .withString(":v_custmid", "[email protected]") 
            .withNumber(":v_openstat", 1));  
         
         querySpec.withProjectionExpression( 
            "OrderDate, ProdCat, ProdNomenclature, OrderStatus"); 
            ItemCollection<QueryOutcome> items = index.query(querySpec); 
            Iterator<Item> iterator = items.iterator();  
            System.out.println("Printing query results...");  
            
         while (iterator.hasNext()) { 
            System.out.println(iterator.next().toJSONPretty()); 
         }  
      } else if (indexName == "OrderDateIndex") { 
         System.out.println("\nUsing index: '" + indexName 
            + "': this customer's orders placed after 05/22/2016."); 
         System.out.println("Projected attributes are returned\n"); 
         Index index = table.getIndex(indexName); 
             
         querySpec.withKeyConditionExpression("CustomerID = :v_custmid and OrderDate 
            >= :v_ordrdate") 
            .withValueMap(new ValueMap() 
            .withString(":v_custmid", "[email protected]") 
            .withNumber(":v_ordrdate", 20160522));
               
         querySpec.withSelect(Select.ALL_PROJECTED_ATTRIBUTES);  
         ItemCollection<QueryOutcome> items = index.query(querySpec); 
         Iterator<Item> iterator = items.iterator();  
         System.out.println("Printing query results...");  
            
         while (iterator.hasNext()) { 
            System.out.println(iterator.next().toJSONPretty()); 
         }  
      } else { 
         System.out.println("\nNo index: All Jane's orders by OrderID:\n"); 
         querySpec.withKeyConditionExpression("CustomerID = :v_custmid") 
            .withValueMap(new ValueMap()
            .withString(":v_custmid", "[email protected]"));  
         
         ItemCollection<QueryOutcome> items = table.query(querySpec); 
         Iterator<Item> iterator = items.iterator();  
         System.out.println("Printing query results...");  
         
         while (iterator.hasNext()) { 
            System.out.println(iterator.next().toJSONPretty()); 
         } 
      } 
   } 
}

DynamoDB ne fournit pas de fonctions d'agrégation. Vous devez utiliser de manière créative les requêtes, les analyses, les index et divers outils pour effectuer ces tâches. Dans tout cela, la dépense de débit des requêtes / analyses dans ces opérations peut être lourde.

Vous avez également la possibilité d'utiliser des bibliothèques et d'autres outils pour votre langage de codage DynamoDB préféré. Assurez-vous de leur compatibilité avec DynamoDB avant de l'utiliser.

Calculer le maximum ou le minimum

Utilisez l'ordre de stockage croissant / décroissant des résultats, le paramètre Limit et tous les paramètres qui définissent l'ordre pour trouver les valeurs les plus élevées et les plus basses.

Par exemple -

Map<String, AttributeValue> eaval = new HashMap<>(); 
eaval.put(":v1", new AttributeValue().withS("hashval")); 
queryExpression = new DynamoDBQueryExpression<Table>() 
   .withIndexName("yourindexname") 
   .withKeyConditionExpression("HK = :v1") 
   .withExpressionAttributeValues(values) 
   .withScanIndexForward(false);                //descending order 

queryExpression.setLimit(1); 
QueryResultPage<Lookup> res = 
   dynamoDBMapper.queryPage(Table.class, queryExpression);

Calculer le nombre

Utilisation DescribeTablepour obtenir un décompte des éléments du tableau, cependant, notez qu'il fournit des données obsolètes. Utilisez également JavagetScannedCount method.

Utiliser LastEvaluatedKey pour s'assurer qu'il donne tous les résultats.

Par exemple -

ScanRequest scanRequest = new ScanRequest().withTableName(yourtblName); 
ScanResult yourresult = client.scan(scanRequest); 
System.out.println("#items:" + yourresult.getScannedCount());

Calcul de la moyenne et de la somme

Utilisez des index et une requête / analyse pour récupérer et filtrer les valeurs avant le traitement. Ensuite, opérez simplement sur ces valeurs via un objet.

DynamoDB utilise les informations d'identification que vous fournissez pour authentifier les demandes. Ces informations d'identification sont obligatoires et doivent inclure des autorisations d'accès aux ressources AWS. Ces autorisations couvrent pratiquement tous les aspects de DynamoDB jusqu'aux fonctionnalités mineures d'une opération ou d'une fonctionnalité.

Types d'autorisations

Dans cette section, nous discuterons des différentes autorisations et accès aux ressources dans DynamoDB.

Authentification des utilisateurs

Lors de votre inscription, vous avez fourni un mot de passe et une adresse e-mail, qui servent d'identifiants root. DynamoDB associe ces données à votre compte AWS et les utilise pour donner un accès complet à toutes les ressources.

AWS vous recommande d'utiliser vos informations d'identification racine uniquement pour la création d'un compte d'administration. Cela vous permet de créer des comptes / utilisateurs IAM avec moins de privilèges. Les utilisateurs IAM sont d'autres comptes générés avec le service IAM. Leurs autorisations / privilèges d'accès incluent l'accès aux pages sécurisées et certaines autorisations personnalisées telles que la modification de table.

Les clés d'accès offrent une autre option pour des comptes et un accès supplémentaires. Utilisez-les pour accorder l'accès et pour éviter l'octroi manuel de l'accès dans certaines situations. Les utilisateurs fédérés offrent encore une autre option en autorisant l'accès via un fournisseur d'identité.

Administration

Les ressources AWS restent sous la propriété d'un compte. Les stratégies d'autorisations régissent les autorisations accordées pour générer ou accéder aux ressources. Les administrateurs associent les stratégies d'autorisations aux identités IAM, c'est-à-dire aux rôles, groupes, utilisateurs et services. Ils attachent également des autorisations aux ressources.

Les autorisations spécifient les utilisateurs, les ressources et les actions. Remarque les administrateurs sont simplement des comptes avec des privilèges d'administrateur.

Fonctionnement et ressources

Les tables restent les principales ressources de DynamoDB. Les sous-ressources servent de ressources supplémentaires, par exemple, des flux et des indices. Ces ressources utilisent des noms uniques, dont certains sont mentionnés dans le tableau suivant -

Type	ARN (nom de la ressource Amazon)
Courant	arn: aws: dynamodb: region: account-id: table / table-name / stream / stream-label
Indice	arn: aws: dynamodb: region: account-id: table / table-name / index / index-name
Table	arn: aws: dynamodb: region: account-id: table / table-name

La possession

Un propriétaire de ressource est défini comme un compte AWS qui a engendré la ressource, ou un compte d'entité principale responsable de l'authentification des demandes lors de la création de ressources. Considérez comment cela fonctionne dans l'environnement DynamoDB -

En utilisant les informations d'identification racine pour créer une table, votre compte reste propriétaire de la ressource.
Lors de la création d'un utilisateur IAM et de l'octroi à l'utilisateur de l'autorisation de créer une table, votre compte reste le propriétaire de la ressource.
En créant un utilisateur IAM et en accordant à l'utilisateur, et à toute personne capable d'assumer le rôle, l'autorisation de créer une table, votre compte reste le propriétaire de la ressource.

Gérer l'accès aux ressources

La gestion des accès nécessite principalement une attention à une politique d'autorisations décrivant les utilisateurs et l'accès aux ressources. Vous associez des stratégies à des identités ou des ressources IAM. Cependant, DynamoDB ne prend en charge que les stratégies IAM / d'identité.

Les stratégies basées sur l'identité (IAM) vous permettent d'accorder des privilèges des manières suivantes:

Attachez des autorisations aux utilisateurs ou aux groupes.
Attachez des autorisations aux rôles pour les autorisations entre comptes.

D'autres AWS autorisent les stratégies basées sur les ressources. Ces stratégies permettent d'accéder à des éléments tels qu'un compartiment S3.

Éléments de politique

Les politiques définissent les actions, les effets, les ressources et les principes; et accordez la permission d'effectuer ces opérations.

Note - Les opérations de l'API peuvent nécessiter des autorisations pour plusieurs actions.

Examinez de plus près les éléments politiques suivants -

Resource - Un ARN l'identifie.
Action - Les mots clés identifient ces opérations sur les ressources et indiquent s'il faut autoriser ou refuser.
Effect - Il spécifie l'effet d'une demande utilisateur pour une action, c'est-à-dire autoriser ou refuser avec le refus par défaut.
Principal - Cela identifie l'utilisateur attaché à la politique.

Conditions

Lors de l'octroi d'autorisations, vous pouvez spécifier des conditions pour le moment où les stratégies deviennent actives, par exemple à une date particulière. Conditions express avec des clés de condition, qui incluent des clés à l'échelle du système AWS et des clés DynamoDB. Ces clés sont décrites en détail plus loin dans le didacticiel.

Autorisations de la console

Un utilisateur a besoin de certaines autorisations de base pour utiliser la console. Ils nécessitent également des autorisations pour la console dans d'autres services standard -

CloudWatch
Pipeline de données
Gestion des identités et des accès
Service de notification
Lambda

Si la stratégie IAM s'avère trop limitée, l'utilisateur ne peut pas utiliser efficacement la console. De plus, vous n'avez pas à vous soucier des autorisations des utilisateurs pour ceux qui appellent uniquement la CLI ou l'API.

Stratégies Iam à usage commun

AWS couvre les opérations courantes dans les autorisations avec des stratégies gérées IAM autonomes. Ils fournissent des autorisations clés vous permettant d'éviter des enquêtes approfondies sur ce que vous devez accorder.

Certains d'entre eux sont les suivants -

AmazonDynamoDBReadOnlyAccess - Il donne un accès en lecture seule via la console.
AmazonDynamoDBFullAccess - Il donne un accès complet via la console.
AmazonDynamoDBFullAccesswithDataPipeline - Il donne un accès complet via la console et permet l'exportation / l'importation avec Data Pipeline.

Vous pouvez également bien sûr créer des politiques personnalisées.

Octroi de privilèges: utilisation du shell

Vous pouvez accorder des autorisations avec le shell Javascript. Le programme suivant montre une politique d'autorisations typique -

{ 
   "Version": "2016-05-22", 
   "Statement": [ 
      { 
         "Sid": "DescribeQueryScanToolsTable", 
         "Effect": "Deny", 
         
         "Action": [ 
            "dynamodb:DescribeTable", 
            "dynamodb:Query", 
            "dynamodb:Scan" 
         ], 
         "Resource": "arn:aws:dynamodb:us-west-2:account-id:table/Tools" 
      } 
   ] 
}

Vous pouvez consulter les trois exemples qui sont les suivants -

Block the user from executing any table action.

{ 
   "Version": "2016-05-23", 
   "Statement": [ 
      { 
         "Sid": "AllAPIActionsOnTools", 
         "Effect": "Deny", 
         "Action": "dynamodb:*", 
         "Resource": "arn:aws:dynamodb:us-west-2:155556789012:table/Tools" 
      } 
   ] 
}

Block access to a table and its indices.

{ 
   "Version": "2016-05-23", 
   "Statement": [ 
      { 
         "Sid": "AccessAllIndexesOnTools", 
         "Effect": "Deny", 
         "Action": [
            "dynamodb:*" 
         ], 
         "Resource": [ 
            "arn:aws:dynamodb:us-west-2:155556789012:table/Tools", 
            "arn:aws:dynamodb:us-west-2:155556789012:table/Tools/index/*" 
         ] 
      } 
   ] 
}

Block a user from making a reserved capacity offering purchase.

{ 
   "Version": "2016-05-23", 
   "Statement": [ 
      { 
         "Sid": "BlockReservedCapacityPurchases", 
         "Effect": "Deny", 
         "Action": "dynamodb:PurchaseReservedCapacityOfferings", 
         "Resource": "arn:aws:dynamodb:us-west-2:155556789012:*" 
      } 
   ] 
}

Octroi de privilèges: utilisation de la console GUI

Vous pouvez également utiliser la console GUI pour créer des stratégies IAM. Pour commencer, choisissezTablesdepuis le volet de navigation. Dans la liste des tableaux, choisissez la table cible et procédez comme suit.

Step 1 - Sélectionnez le Access control languette.

Step 2- Sélectionnez le fournisseur d'identité, les actions et les attributs de stratégie. SélectionnerCreate policy après avoir entré tous les paramètres.

Step 3 - Choisissez Attach policy instructionset effectuez chaque étape requise pour associer la stratégie au rôle IAM approprié.

L'API DynamoDB propose un large ensemble d'actions, qui nécessitent des autorisations. Lors de la définition des autorisations, vous devez définir les actions autorisées, les ressources autorisées et les conditions de chacune.

Vous pouvez spécifier des actions dans le champ Action de la stratégie. Spécifiez la valeur de la ressource dans le champ Ressource de la stratégie. Mais assurez-vous que vous utilisez la syntaxe correcte contenant le préfixe Dynamodb: avec l'opération API.

Par exemple - dynamodb:CreateTable

Vous pouvez également utiliser des clés de condition pour filtrer les autorisations.

Autorisations et actions d'API

Regardez bien les actions de l'API et les autorisations associées données dans le tableau suivant -

Fonctionnement de l'API	Autorisation nécessaire
BatchGetItem	dynamodb: BatchGetItem
BatchWriteItem	dynamodb: BatchWriteItem
CreateTable	dynamodb: CreateTable
Effacer l'article	dynamodb: DeleteItem
SupprimerTable	dynamodb: DeleteTable
Décrire les limites	dynamodb: DescribeLimits
DécrireCapacité réservée	dynamodb: DescribeReservedCapacity
DécrireRéservéCapacitéOffres	dynamodb: DescribeReservedCapacityOfferings
DécrireStream	dynamodb: DescribeStream
DécrireTable	dynamodb: DescribeTable
Obtenir l'article	dynamodb: GetItem
GetRecords	dynamodb: GetRecords
GetShardIterator	dynamodb: GetShardIterator
ListeStreams	dynamodb: ListStreams
ListeTables	dynamodb: ListTables
AchatRéservéCapacitéOffres	dynamodb: PurchaseReservedCapacityOfferings
PutItem	dynamodb: PutItem
Requete	dynamodb: requête
Analyse	dynamodb: Scan
UpdateItem	dynamodb: UpdateItem
UpdateTable	dynamodb: UpdateTable

Ressources

Dans le tableau suivant, vous pouvez consulter les ressources associées à chaque action d'API autorisée -

Fonctionnement de l'API	Ressource
BatchGetItem	arn: aws: dynamodb: region: account-id: table / table-name
BatchWriteItem	arn: aws: dynamodb: region: account-id: table / table-name
CreateTable	arn: aws: dynamodb: region: account-id: table / table-name
Effacer l'article	arn: aws: dynamodb: region: account-id: table / table-name
SupprimerTable	arn: aws: dynamodb: region: account-id: table / table-name
Décrire les limites	arn: aws: dynamodb: region: account-id: *
DécrireCapacité réservée	arn: aws: dynamodb: region: account-id: *
DécrireRéservéCapacitéOffres	arn: aws: dynamodb: region: account-id: *
DécrireStream	arn: aws: dynamodb: region: account-id: table / table-name / stream / stream-label
DécrireTable	arn: aws: dynamodb: region: account-id: table / table-name
Obtenir l'article	arn: aws: dynamodb: region: account-id: table / table-name
GetRecords	arn: aws: dynamodb: region: account-id: table / table-name / stream / stream-label
GetShardIterator	arn: aws: dynamodb: region: account-id: table / table-name / stream / stream-label
ListeStreams	arn: aws: dynamodb: region: account-id: table / table-name / stream / *
ListeTables	*
AchatRéservéCapacitéOffres	arn: aws: dynamodb: region: account-id: *
PutItem	arn: aws: dynamodb: region: account-id: table / table-name
Requete	arn: aws: dynamodb: region: account-id: table / table-name ou arn: aws: dynamodb: region: account-id: table / table-name / index / index-name
Analyse	arn: aws: dynamodb: region: account-id: table / table-name ou arn: aws: dynamodb: region: account-id: table / table-name / index / index-name
UpdateItem	arn: aws: dynamodb: region: account-id: table / table-name
UpdateTable	arn: aws: dynamodb: region: account-id: table / table-name

En accordant des autorisations, DynamoDB permet de spécifier des conditions pour celles-ci via une stratégie IAM détaillée avec des clés de condition. Cela prend en charge des paramètres tels que l'accès à des éléments et attributs spécifiques.

Note - Le DynamoDB ne prend en charge aucune balise.

Contrôle détaillé

Plusieurs conditions permettent la spécificité des éléments et des attributs tels que l'octroi d'un accès en lecture seule à des éléments spécifiques en fonction du compte d'utilisateur. Implémentez ce niveau de contrôle avec des stratégies IAM conditionnées, qui gèrent les informations d'identification de sécurité. Ensuite, appliquez simplement la stratégie aux utilisateurs, groupes et rôles souhaités. Web Identity Federation, un sujet abordé plus tard, fournit également un moyen de contrôler l'accès des utilisateurs via les connexions Amazon, Facebook et Google.

L'élément condition de la stratégie IAM implémente le contrôle d'accès. Vous l'ajoutez simplement à une politique. Un exemple de son utilisation consiste à refuser ou à autoriser l'accès aux éléments et attributs de table. L'élément condition peut également utiliser des clés de condition pour limiter les autorisations.

Vous pouvez consulter les deux exemples suivants de clés de condition -

dynamodb:LeadingKeys - Il empêche l'accès à l'élément par les utilisateurs sans ID correspondant à la valeur de la clé de partition.
dynamodb:Attributes - Il empêche les utilisateurs d'accéder ou d'opérer sur des attributs en dehors de ceux répertoriés.

Lors de l'évaluation, les stratégies IAM donnent une valeur vraie ou fausse. Si une partie est évaluée à false, l'ensemble de la stratégie est évaluée à false, ce qui entraîne un refus d'accès. Assurez-vous de spécifier toutes les informations requises dans les clés de condition pour vous assurer que les utilisateurs disposent d'un accès approprié.

Clés de condition prédéfinies

AWS propose une collection de clés de condition prédéfinies, qui s'appliquent à tous les services. Ils prennent en charge un large éventail d'utilisations et des détails fins lors de l'examen des utilisateurs et de l'accès.

Note - Il y a une sensibilité à la casse dans les clés de condition.

Vous pouvez consulter une sélection des clés spécifiques au service suivantes -

dynamodb:LeadingKey- Il représente le premier attribut clé d'une table; la clé de partition. Utilisez le modificateur ForAllValues dans les conditions.
dynamodb:Select- Il représente un paramètre de sélection de requête / requête d'analyse. Il doit avoir la valeur ALL_ATTRIBUTES, ALL_PROJECTED_ATTRIBUTES, SPECIFIC_ATTRIBUTES ou COUNT.
dynamodb:Attributes- Il représente une liste de noms d'attributs dans une demande, ou des attributs renvoyés par une demande. Ses valeurs et leurs fonctions ressemblent aux paramètres d'action de l'API, par exemple, BatchGetItem utilise AttributesToGet.
dynamodb:ReturnValues - Il représente le paramètre ReturnValues d'une requête et peut utiliser ces valeurs: ALL_OLD, UPDATED_OLD, ALL_NEW, UPDATED_NEW et NONE.
dynamodb:ReturnConsumedCapacity - Il représente le paramètre ReturnConsumedCapacity d'une requête et peut utiliser les valeurs suivantes: TOTAL et NONE.

Web Identity Federation vous permet de simplifier l'authentification et l'autorisation pour les grands groupes d'utilisateurs. Vous pouvez ignorer la création de comptes individuels et demander aux utilisateurs de se connecter à un fournisseur d'identité pour obtenir des informations d'identification ou des jetons temporaires. Il utilise AWS Security Token Service (STS) pour gérer les informations d'identification. Les applications utilisent ces jetons pour interagir avec les services.

Web Identity Federation prend également en charge d'autres fournisseurs d'identité tels que - Amazon, Google et Facebook.

Function- En cours d'utilisation, Web Identity Federation appelle d'abord un fournisseur d'identité pour l'authentification des utilisateurs et des applications, et le fournisseur renvoie un jeton. Il en résulte que l'application appelle AWS STS et transmet le jeton pour l'entrée. STS autorise l'application et lui accorde des informations d'identification d'accès temporaires, qui permettent à l'application d'utiliser un rôle IAM et d'accéder aux ressources en fonction de la stratégie.

Implémentation de la fédération d'identité Web

Vous devez effectuer les trois étapes suivantes avant l'utilisation -

Utilisez un fournisseur d'identité tiers pris en charge pour vous inscrire en tant que développeur.
Enregistrez votre application auprès du fournisseur pour obtenir un identifiant d'application.
Créez un ou plusieurs rôles IAM, y compris l'attachement de stratégie. Vous devez utiliser un rôle par fournisseur et par application.

Assumez l'un de vos rôles IAM pour utiliser Web Identity Federation. Votre application doit ensuite effectuer un processus en trois étapes -

Authentication
Acquisition d'informations d'identification
Accès aux ressources

Dans la première étape, votre application utilise sa propre interface pour appeler le fournisseur, puis gère le processus de jeton.

Ensuite, la deuxième étape gère les jetons et nécessite que votre application envoie un AssumeRoleWithWebIdentitydemande à AWS STS. La demande contient le premier jeton, l'ID d'application du fournisseur et l'ARN du rôle IAM. Le STS fournit des informations d'identification définies pour expirer après une certaine période.

À l'étape finale, votre application reçoit une réponse de STS contenant des informations d'accès aux ressources DynamoDB. Il comprend les informations d'identification d'accès, l'heure d'expiration, le rôle et l'ID de rôle.

Le pipeline de données permet d'exporter et d'importer des données vers / depuis une table, un fichier ou un compartiment S3. Cela s'avère bien sûr utile dans les sauvegardes, les tests et pour des besoins ou des scénarios similaires.

Dans une exportation, vous utilisez la console Data Pipeline, qui crée un nouveau pipeline et lance un cluster Amazon EMR (Elastic MapReduce) pour effectuer l'exportation. Un EMR lit les données de DynamoDB et écrit dans la cible. Nous aborderons le DME en détail plus loin dans ce didacticiel.

Dans une opération d'importation, vous utilisez la console Data Pipeline, qui crée un pipeline et lance EMR pour effectuer l'importation. Il lit les données de la source et écrit dans la destination.

Note - Les opérations d'exportation / importation ont un coût compte tenu des services utilisés, notamment EMR et S3.

Utilisation du pipeline de données

Vous devez spécifier les autorisations d'action et de ressource lors de l'utilisation de Data Pipeline. Vous pouvez utiliser un rôle ou une stratégie IAM pour les définir. Les utilisateurs qui effectuent des importations / exportations doivent noter qu'ils auraient besoin d'un ID de clé d'accès actif et d'une clé secrète.

Rôles IAM pour le pipeline de données

Vous avez besoin de deux rôles IAM pour utiliser Data Pipeline -

DataPipelineDefaultRole - Cela contient toutes les actions que vous autorisez le pipeline à effectuer pour vous.
DataPipelineDefaultResourceRole - Cela a des ressources que vous autorisez le pipeline à provisionner pour vous.

Si vous êtes nouveau dans Data Pipeline, vous devez générer chaque rôle. Tous les utilisateurs précédents possèdent ces rôles en raison des rôles existants.

Utilisez la console IAM pour créer des rôles IAM pour Data Pipeline et effectuez les quatre étapes suivantes:

Step 1 - Connectez-vous à la console IAM située à https://console.aws.amazon.com/iam/

Step 2 - Sélectionnez Roles depuis le tableau de bord.

Step 3 - Sélectionnez Create New Role. Entrez ensuite DataPipelineDefaultRole dans leRole Name champ et sélectionnez Next Step. dans leAWS Service Roles liste dans le Role Type panneau, accédez à Data Pipeline, et choisissez Select. SélectionnerCreate Role dans le Review panneau.

Step 4 - Sélectionnez Create New Role.

Utilisez la fonctionnalité d'importation / exportation de Data Pipeline pour effectuer des sauvegardes. La manière dont vous exécutez une sauvegarde varie selon que vous utilisez la console GUI ou que vous utilisez directement Data Pipeline (API). Créez des pipelines séparés pour chaque table lors de l'utilisation de la console ou importez / exportez plusieurs tables dans un seul pipeline si vous utilisez une option directe.

Exportation et importation de données

Vous devez créer un compartiment Amazon S3 avant d'effectuer une exportation. Vous pouvez exporter à partir d'une ou plusieurs tables.

Exécutez le processus en quatre étapes suivant pour exécuter une exportation -

Step 1 - Connectez-vous à AWS Management Console et ouvrez la console Data Pipeline située sur https://console.aws.amazon.com/datapipeline/

Step 2 - Si vous n'avez pas de pipelines dans la région AWS utilisée, sélectionnez Get started now. Si vous en avez un ou plusieurs, sélectionnezCreate new pipeline.

Step 3- Sur la page de création, entrez un nom pour votre pipeline. ChoisirBuild using a templatepour le paramètre Source. SélectionnerExport DynamoDB table to S3de la liste. Entrez la table source dans leSource DynamoDB table name champ.

Entrez le compartiment S3 de destination dans le Output S3 Folderzone de texte au format suivant: s3: // nameOfBucket / region / nameOfFolder. Entrez une destination S3 pour le fichier journal dansS3 location for logs zone de texte.

Step 4 - Sélectionnez Activate après avoir entré tous les paramètres.

Le pipeline peut prendre plusieurs minutes pour terminer son processus de création. Utilisez la console pour surveiller son état. Confirmez la réussite du traitement avec la console S3 en affichant le fichier exporté.

Importer des données

Les importations réussies ne peuvent se produire que si les conditions suivantes sont remplies: vous avez créé une table de destination, la destination et la source utilisent des noms identiques, et la destination et la source utilisent un schéma de clé identique.

Vous pouvez utiliser une table de destination remplie, cependant, les importations remplacent les éléments de données partageant une clé avec les éléments source et ajoutent également des éléments en excès à la table. La destination peut également utiliser une région différente.

Bien que vous puissiez exporter plusieurs sources, vous ne pouvez en importer qu'une par opération. Vous pouvez effectuer une importation en suivant les étapes suivantes -

Step 1 - Connectez-vous à AWS Management Console, puis ouvrez la console Data Pipeline.

Step 2 - Si vous avez l'intention d'exécuter une importation interrégionale, vous devez sélectionner la région de destination.

Step 3 - Sélectionnez Create new pipeline.

Step 4 - Entrez le nom du pipeline dans le Namechamp. ChoisirBuild using a template pour le paramètre Source, et dans la liste des modèles, sélectionnez Import DynamoDB backup data from S3.

Entrez l'emplacement du fichier source dans le Input S3 Folderzone de texte. Entrez le nom de la table de destination dans leTarget DynamoDB table namechamp. Entrez ensuite l'emplacement du fichier journal dans leS3 location for logs zone de texte.

Step 5 - Sélectionnez Activate après avoir entré tous les paramètres.

L'importation démarre immédiatement après la création du pipeline. Le processus de création du pipeline peut prendre plusieurs minutes.

les erreurs

Lorsque des erreurs se produisent, la console Data Pipeline affiche ERROR comme état du pipeline. En cliquant sur le pipeline avec une erreur, vous accédez à sa page de détails, qui révèle chaque étape du processus et le point auquel l'échec s'est produit. Les fichiers journaux à l'intérieur fournissent également des informations.

Vous pouvez examiner les causes courantes des erreurs comme suit -

La table de destination d'une importation n'existe pas ou n'utilise pas de schéma de clé identique à la source.
Le compartiment S3 n'existe pas ou vous ne disposez pas des autorisations de lecture / écriture pour celui-ci.
Le pipeline a expiré.
Vous ne disposez pas des autorisations d'exportation / importation nécessaires.
Votre compte AWS a atteint sa limite de ressources.

Amazon propose CloudWatch pour agréger et analyser les performances via la console CloudWatch, la ligne de commande ou l'API CloudWatch. Vous pouvez également l'utiliser pour définir des alarmes et effectuer des tâches. Il effectue des actions spécifiées sur certains événements.

Console Cloudwatch

Utilisez CloudWatch en accédant à la console de gestion, puis en ouvrant la console CloudWatch à l'adresse https://console.aws.amazon.com/cloudwatch/.

Vous pouvez ensuite effectuer les étapes suivantes -

Sélectionner Metrics depuis le volet de navigation.
Sous les métriques DynamoDB dans le CloudWatch Metrics by Category volet, choisissez Table Metrics.
Utilisez le volet supérieur pour faire défiler ci-dessous et examiner la liste complète des mesures de table. leViewing list fournit des options de métriques.

Dans l'interface des résultats, vous pouvez sélectionner / désélectionner chaque métrique en cochant la case en regard du nom de la ressource et de la métrique. Ensuite, vous pourrez afficher des graphiques pour chaque élément.

Intégration API

Vous pouvez accéder à CloudWatch avec des requêtes. Utilisez des valeurs de métrique pour effectuer des actions CloudWatch. Remarque DynamoDB n'envoie pas de métriques avec une valeur de zéro. Il ignore simplement les métriques pour les périodes où ces métriques restent à cette valeur.

Voici quelques-unes des mesures les plus couramment utilisées:

ConditionalCheckFailedRequests- Il suit le nombre de tentatives infructueuses d'écritures conditionnelles telles que les écritures PutItem conditionnelles. Les écritures ayant échoué incrémentent cette métrique de un lors de l'évaluation à false. Il génère également une erreur HTTP 400.
ConsumedReadCapacityUnits- Il quantifie les unités de capacité utilisées sur une certaine période. Vous pouvez l'utiliser pour examiner la consommation individuelle des tables et des index.
ConsumedWriteCapacityUnits- Il quantifie les unités de capacité utilisées sur une certaine période. Vous pouvez l'utiliser pour examiner la consommation individuelle des tables et des index.
ReadThrottleEvents- Il quantifie les demandes dépassant les unités de capacité provisionnées dans les lectures de table / index. Il s'incrémente sur chaque accélérateur, y compris les opérations par lots avec plusieurs régulateurs.
ReturnedBytes - Il quantifie les octets retournés dans les opérations de récupération dans un certain laps de temps.
ReturnedItemCount- Il quantifie les éléments retournés dans les opérations de requête et d'analyse sur une certaine période. Il ne concerne que les articles retournés, pas ceux évalués, qui sont généralement des chiffres totalement différents.

Note - Il existe de nombreuses autres métriques, et la plupart d'entre elles vous permettent de calculer des moyennes, des sommes, des maximums, des minimums et des décomptes.

DynamoDB inclut l'intégration CloudTrail. Il capture les demandes d'API de bas niveau de ou pour DynamoDB dans un compte et envoie des fichiers journaux à un compartiment S3 spécifié. Il cible les appels depuis la console ou l'API. Vous pouvez utiliser ces données pour déterminer les demandes effectuées et leur source, utilisateur, horodatage, etc.

Lorsqu'il est activé, il suit les actions dans les fichiers journaux, qui incluent d'autres enregistrements de service. Il prend en charge huit actions et deux flux -

Les huit actions sont les suivantes -

CreateTable
DeleteTable
DescribeTable
ListTables
UpdateTable
DescribeReservedCapacity
DescribeReservedCapacityOfferings
PurchaseReservedCapacityOfferings

Alors que les deux flux sont -

DescribeStream
ListStreams

Tous les journaux contiennent des informations sur les comptes faisant des demandes. Vous pouvez déterminer des informations détaillées telles que si les utilisateurs root ou IAM ont effectué la demande, ou avec des informations d'identification temporaires ou fédérées.

Les fichiers journaux restent stockés aussi longtemps que vous le spécifiez, avec des paramètres d'archivage et de suppression. La valeur par défaut crée des journaux chiffrés. Vous pouvez définir des alertes pour les nouveaux journaux. Vous pouvez également organiser plusieurs journaux, à travers les régions et les comptes, dans un seul compartiment.

Interprétation des fichiers journaux

Chaque fichier contient une ou plusieurs entrées. Chaque entrée se compose de plusieurs événements au format JSON. Une entrée représente une demande et comprend des informations associées; sans garantie de commande.

Vous pouvez consulter l'exemple de fichier journal suivant -

{"Records": [ 
   { 
      "eventVersion": "5.05",  
      "userIdentity": {
         "type": "AssumedRole", 
         "principalId": "AKTTIOSZODNN8SAMPLE:jane", 
         "arn": "arn:aws:sts::155522255533:assumed-role/users/jane", 
         "accountId": "155522255533", 
         "accessKeyId": "AKTTIOSZODNN8SAMPLE", 
         
         "sessionContext": { 
            "attributes": { 
               "mfaAuthenticated": "false", 
               "creationDate": "2016-05-11T19:01:01Z" 
            },
            
            "sessionIssuer": { 
               "type": "Role", 
               "principalId": "AKTTI44ZZ6DHBSAMPLE", 
               "arn": "arn:aws:iam::499955777666:role/admin-role", 
               "accountId": "499955777666", 
               "userName": "jill" 
            } 
         } 
      },
      
      "eventTime": "2016-05-11T14:33:20Z", 
      "eventSource": "dynamodb.amazonaws.com", 
      "eventName": "DeleteTable", 
      "awsRegion": "us-west-2", 
      "sourceIPAddress": "192.0.2.0", 
      "userAgent": "console.aws.amazon.com", 
      "requestParameters": {"tableName": "Tools"}, 
      
      "responseElements": {"tableDescription": { 
         "tableName": "Tools", 
         "itemCount": 0, 
         
         "provisionedThroughput": { 
            "writeCapacityUnits": 25, 
            "numberOfDecreasesToday": 0, 
            "readCapacityUnits": 25 
         },
         "tableStatus": "DELETING", 
         "tableSizeBytes": 0
      }},
      "requestID": "4D89G7D98GF7G8A7DF78FG89AS7GFSO5AEMVJF66Q9ASUAAJG", 
      "eventID": "a954451c-c2fc-4561-8aea-7a30ba1fdf52", 
      "eventType": "AwsApiCall", 
      "apiVersion": "2013-04-22", 
      "recipientAccountId": "155522255533" 
   } 
]}

Elastic MapReduce (EMR) d'Amazon vous permet de traiter rapidement et efficacement le Big Data. EMR exécute Apache Hadoop sur des instances EC2, mais simplifie le processus. Vous utilisez Apache Hive pour interroger la carte et réduire les flux de travail via HiveQL , un langage de requête ressemblant à SQL. Apache Hive sert à optimiser les requêtes et vos applications.

Vous pouvez utiliser l'onglet EMR de la console de gestion, l'interface de ligne de commande EMR, une API ou un SDK pour lancer un flux de travaux. Vous avez également la possibilité d'exécuter Hive de manière interactive ou d'utiliser un script.

Les opérations de lecture / écriture EMR ont un impact sur la consommation de débit, cependant, dans les demandes volumineuses, il effectue des tentatives avec la protection d'un algorithme d'interruption. En outre, l'exécution d'EMR en même temps que d'autres opérations et tâches peut entraîner une limitation.

L'intégration DynamoDB / EMR ne prend pas en charge les attributs d'ensemble binaire et binaire.

Conditions préalables à l'intégration DynamoDB / EMR

Passez en revue cette liste de contrôle des éléments nécessaires avant d'utiliser le DME -

Un compte AWS
Un tableau rempli sous le même compte utilisé dans les opérations de DME
Une version Hive personnalisée avec connectivité DynamoDB
Prise en charge de la connectivité DynamoDB
Un compartiment S3 (facultatif)
Un client SSH (facultatif)
Une paire de clés EC2 (en option)

Configuration de la ruche

Avant d'utiliser EMR, créez une paire de clés pour exécuter Hive en mode interactif. La paire de clés permet la connexion aux instances EC2 et aux nœuds maîtres des flux de travaux.

Vous pouvez effectuer cela en suivant les étapes suivantes -

Connectez-vous à la console de gestion et ouvrez la console EC2 située à https://console.aws.amazon.com/ec2/
Sélectionnez une région dans la partie supérieure droite de la console. Assurez-vous que la région correspond à la région DynamoDB.
Dans le volet de navigation, sélectionnez Key Pairs.
Sélectionner Create Key Pair.
dans le Key Pair Name champ, entrez un nom et sélectionnez Create.
Téléchargez le fichier de clé privée résultant qui utilise le format suivant: filename.pem.

Note - Vous ne pouvez pas vous connecter aux instances EC2 sans la paire de clés.

Cluster ruche

Créez un cluster compatible Hive pour exécuter Hive. Il crée l'environnement d'applications et d'infrastructure requis pour une connexion Hive-to-DynamoDB.

Vous pouvez effectuer cette tâche en utilisant les étapes suivantes -

Accédez à la console EMR.
Sélectionner Create Cluster.
Dans l'écran de création, définissez la configuration du cluster avec un nom descriptif pour le cluster, sélectionnez Yes pour la protection de la terminaison et vérifier Enabled pour la journalisation, une destination S3 pour log folder S3 location, et Enabled pour le débogage.
Dans l'écran de configuration du logiciel, assurez-vous que les champs tiennent Amazon pour la distribution Hadoop, la dernière version de la version AMI, une version Hive par défaut pour les applications à installer-Hive et une version Pig par défaut pour les applications à installer-Pig.
Dans l'écran de configuration matérielle, assurez-vous que les champs tiennent Launch into EC2-Classic pour le réseau, No Preference pour la zone de disponibilité EC2, la valeur par défaut pour le type d'instance maître-Amazon EC2, pas de vérification pour les instances Spot de demande, la valeur par défaut pour le type d'instance Core-Amazon EC2, 2 pour Count, pas de vérification pour Request Spot Instances, valeur par défaut pour Task-Amazon EC2 Instance Type, 0 pour Count, et pas de contrôle pour Request Spot Instances.

Assurez-vous de définir une limite fournissant une capacité suffisante pour éviter une défaillance du cluster.

Dans l'écran Sécurité et accès, assurez-vous que les champs contiennent votre paire de clés dans la paire de clés EC2, No other IAM users dans l'accès des utilisateurs IAM, et Proceed without roles dans le rôle IAM.
Consultez l'écran Actions d'amorçage, mais ne le modifiez pas.
Vérifiez les paramètres et sélectionnez Create Cluster Une fois terminé.

UNE Summary Le volet apparaît au début du cluster.

Activer la session SSH

Vous avez besoin d'une session SSH active pour vous connecter au nœud maître et exécuter les opérations CLI. Localisez le nœud maître en sélectionnant le cluster dans la console EMR. Il répertorie le nœud maître commeMaster Public DNS Name.

Installez PuTTY si vous ne l'avez pas. Puis lancez PuTTYgen et sélectionnezLoad. Choisissez votre fichier PEM et ouvrez-le. PuTTYgen vous informera de la réussite de l'importation. SélectionnerSave private key pour enregistrer au format de clé privée PuTTY (PPK), et choisissez Yespour enregistrer sans phrase de passe. Entrez ensuite un nom pour la clé PuTTY, appuyez surSaveet fermez PuTTYgen.

Utilisez PuTTY pour établir une connexion avec le nœud maître en démarrant d'abord PuTTY. ChoisirSessiondans la liste Catégorie. Entrez hadoop @ DNS dans le champ Nom d'hôte. DévelopperConnection > SSH dans la liste Catégorie et choisissez Auth. Dans l'écran des options de contrôle, sélectionnezBrowsepour le fichier de clé privée pour l'authentification. Sélectionnez ensuite votre fichier de clé privée et ouvrez-le. SélectionnerYes pour la fenêtre contextuelle d'alerte de sécurité.

Une fois connecté au nœud maître, une invite de commande Hadoop apparaît, ce qui signifie que vous pouvez démarrer une session Hive interactive.

Table de ruche

Hive sert d'outil d'entrepôt de données permettant des requêtes sur des clusters EMR à l'aide de HiveQL . Les configurations précédentes vous donnent une invite de travail. Exécutez les commandes Hive de manière interactive en entrant simplement «ruche», puis toutes les commandes que vous souhaitez. Consultez notre didacticiel Hive pour plus d'informations sur Hive .

Les flux DynamoDB vous permettent de suivre et de répondre aux modifications des éléments de table. Utilisez cette fonctionnalité pour créer une application qui répond aux changements en mettant à jour les informations entre les sources. Synchronisez les données de milliers d'utilisateurs d'un grand système multi-utilisateurs. Utilisez-le pour envoyer des notifications aux utilisateurs sur les mises à jour. Ses applications s'avèrent diverses et substantielles. Les flux DynamoDB sont le principal outil utilisé pour réaliser cette fonctionnalité.

Les flux capturent des séquences ordonnées dans le temps contenant des modifications d'éléments dans une table. Ils conservent ces données pendant un maximum de 24 heures. Les applications les utilisent pour afficher les éléments originaux et modifiés, presque en temps réel.

Les flux activés sur une table capturent toutes les modifications. Sur toute opération CRUD, DynamoDB crée un enregistrement de flux avec les attributs de clé primaire des éléments modifiés. Vous pouvez configurer des flux pour des informations supplémentaires telles que les images avant et après.

Les Streams comportent deux garanties -

Chaque enregistrement apparaît une fois dans le flux et
Chaque modification d'élément entraîne les enregistrements de flux du même ordre que celui des modifications.

Tous les flux sont traités en temps réel pour vous permettre de les utiliser pour les fonctionnalités associées dans les applications.

Gérer les flux

Lors de la création de table, vous pouvez activer un flux. Les tables existantes permettent la désactivation du flux ou la modification des paramètres. Les flux offrent la fonctionnalité de fonctionnement asynchrone, ce qui signifie aucun impact sur les performances de la table.

Utilisez la console AWS Management pour une gestion simple des flux. Tout d'abord, accédez à la console et choisissezTables. Dans l'onglet Présentation, choisissezManage Stream. Dans la fenêtre, sélectionnez les informations ajoutées à un flux sur les modifications de données de table. Après avoir entré tous les paramètres, sélectionnezEnable.

Si vous souhaitez désactiver des flux existants, sélectionnez Manage Stream, et alors Disable.

Vous pouvez également utiliser les API CreateTable et UpdateTable pour activer ou modifier un flux. Utilisez le paramètre StreamSpecification pour configurer le flux. StreamEnabled spécifie l'état, ce qui signifie vrai pour activé et faux pour désactivé.

StreamViewType spécifie les informations ajoutées au flux: KEYS_ONLY, NEW_IMAGE, OLD_IMAGE et NEW_AND_OLD_IMAGES.

Lecture de flux

Lisez et traitez les flux en vous connectant à un point de terminaison et en effectuant des requêtes API. Chaque flux se compose d'enregistrements de flux, et chaque enregistrement existe en tant que modification unique qui possède le flux. Les enregistrements de flux incluent un numéro de séquence révélant l'ordre de publication. Les enregistrements appartiennent à des groupes également appelés fragments. Les fragments fonctionnent comme des conteneurs pour plusieurs enregistrements et contiennent également les informations nécessaires pour accéder aux enregistrements et les parcourir. Après 24 heures, les enregistrements sont automatiquement supprimés.

Ces fragments sont générés et supprimés selon les besoins et ne durent pas longtemps. Ils se divisent également automatiquement en plusieurs nouveaux fragments, généralement en réponse à des pics d'activité d'écriture. Lors de la désactivation du flux, les fragments ouverts se ferment. La relation hiérarchique entre les fragments signifie que les applications doivent donner la priorité aux fragments parents pour un ordre de traitement correct. Vous pouvez utiliser l'adaptateur Kinesis pour le faire automatiquement.

Note - Les opérations sans changement n'écrivent pas les enregistrements de flux.

L'accès et le traitement des enregistrements nécessitent l'exécution des tâches suivantes -

Déterminez l'ARN du flux cible.
Déterminez le (s) fragment (s) du flux contenant les enregistrements cibles.
Accédez au (x) fragment (s) pour récupérer les enregistrements souhaités.

Note- Il doit y avoir au maximum 2 processus lisant un fragment à la fois. S'il dépasse 2 processus, il peut ralentir la source.

Les actions d'API de flux disponibles incluent

ListStreams
DescribeStream
GetShardIterator
GetRecords

Vous pouvez consulter l'exemple suivant de lecture de flux -

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBStreamsClient;

import com.amazonaws.services.dynamodbv2.model.AttributeAction;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.AttributeValueUpdate;

import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.DescribeStreamRequest;
import com.amazonaws.services.dynamodbv2.model.DescribeStreamResult;
import com.amazonaws.services.dynamodbv2.model.DescribeTableResult;

import com.amazonaws.services.dynamodbv2.model.GetRecordsRequest;
import com.amazonaws.services.dynamodbv2.model.GetRecordsResult;
import com.amazonaws.services.dynamodbv2.model.GetShardIteratorRequest;
import com.amazonaws.services.dynamodbv2.model.GetShardIteratorResult;

import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.Record;

import com.amazonaws.services.dynamodbv2.model.Shard;
import com.amazonaws.services.dynamodbv2.model.ShardIteratorType;
import com.amazonaws.services.dynamodbv2.model.StreamSpecification;
import com.amazonaws.services.dynamodbv2.model.StreamViewType;
import com.amazonaws.services.dynamodbv2.util.Tables;

public class StreamsExample {
   private static AmazonDynamoDBClient dynamoDBClient =  
      new AmazonDynamoDBClient(new ProfileCredentialsProvider());  
   private static AmazonDynamoDBStreamsClient streamsClient =  
      new AmazonDynamoDBStreamsClient(new ProfileCredentialsProvider());  

   public static void main(String args[]) {  
      dynamoDBClient.setEndpoint("InsertDbEndpointHere");   
      streamsClient.setEndpoint("InsertStreamEndpointHere");    
      
      // table creation 
      String tableName = "MyTestingTable";  
      ArrayList<AttributeDefinition> attributeDefinitions =  
         new ArrayList<AttributeDefinition>();  
      
      attributeDefinitions.add(new AttributeDefinition()
         .withAttributeName("ID") 
         .withAttributeType("N"));
         
      ArrayList<KeySchemaElement> keySchema = new 
         ArrayList<KeySchemaElement>(); 
      
      keySchema.add(new KeySchemaElement() 
         .withAttributeName("ID") 
         .withKeyType(KeyType.HASH));                       //Partition key

      StreamSpecification streamSpecification = new StreamSpecification(); 
      streamSpecification.setStreamEnabled(true); 
      streamSpecification.setStreamViewType(StreamViewType.NEW_AND_OLD_IMAGES);  
      CreateTableRequest createTableRequest = new CreateTableRequest() 
         .withTableName(tableName) 
         .withKeySchema(keySchema) 
         .withAttributeDefinitions(attributeDefinitions) 
         .withProvisionedThroughput(new ProvisionedThroughput() 
         .withReadCapacityUnits(1L) 
         .withWriteCapacityUnits(1L))
         .withStreamSpecification(streamSpecification);  
      
      System.out.println("Executing CreateTable for " + tableName); 
      dynamoDBClient.createTable(createTableRequest);  
      System.out.println("Creating " + tableName); 
      
      try { 
         Tables.awaitTableToBecomeActive(dynamoDBClient, tableName); 
      } catch (InterruptedException e) { 
         e.printStackTrace(); 
      } 
         
      // Get the table's stream settings 
      DescribeTableResult describeTableResult =
         dynamoDBClient.describeTable(tableName);  
      
      String myStreamArn = describeTableResult.getTable().getLatestStreamArn(); 
      StreamSpecification myStreamSpec =  
         describeTableResult.getTable().getStreamSpecification();  
      
      System.out.println("Current stream ARN for " + tableName + ": "+ myStreamArn);
      System.out.println("Stream enabled: "+ myStreamSpec.getStreamEnabled()); 
      System.out.println("Update view type: "+ myStreamSpec.getStreamViewType());  
      
      // Add an item 
      int numChanges = 0; 
      System.out.println("Making some changes to table data"); 
      Map<String, AttributeValue> item = new HashMap<String, AttributeValue>(); 
      item.put("ID", new AttributeValue().withN("222")); 
      item.put("Alert", new AttributeValue().withS("item!")); 
      dynamoDBClient.putItem(tableName, item); 
      numChanges++;  
      
      // Update the item         
      Map<String, AttributeValue> key = new HashMap<String, AttributeValue>(); 
      key.put("ID", new AttributeValue().withN("222")); 
      Map<String, AttributeValueUpdate> attributeUpdates =  
      new HashMap<String, AttributeValueUpdate>(); 
      
      attributeUpdates.put("Alert", new AttributeValueUpdate() 
         .withAction(AttributeAction.PUT) 
         .withValue(new AttributeValue().withS("modified item"))); 
      
      dynamoDBClient.updateItem(tableName, key, attributeUpdates); 
      numChanges++;   
      
      // Delete the item         
      dynamoDBClient.deleteItem(tableName, key);  
      numChanges++;
      
      // Get stream shards         
      DescribeStreamResult describeStreamResult =  
      streamsClient.describeStream(new DescribeStreamRequest() 
         .withStreamArn(myStreamArn)); 
      String streamArn =  
         describeStreamResult.getStreamDescription().getStreamArn(); 
      List<Shard> shards =  
         describeStreamResult.getStreamDescription().getShards();  
      
      // Process shards 
      for (Shard shard : shards) { 
         String shardId = shard.getShardId(); 
         System.out.println("Processing " + shardId + " in "+ streamArn);  
         
         // Get shard iterator 
         GetShardIteratorRequest getShardIteratorRequest = new 
            GetShardIteratorRequest() 
            .withStreamArn(myStreamArn) 
            .withShardId(shardId) 
            .withShardIteratorType(ShardIteratorType.TRIM_HORIZON); 
         
         GetShardIteratorResult getShardIteratorResult =  
            streamsClient.getShardIterator(getShardIteratorRequest); 
         String nextItr = getShardIteratorResult.getShardIterator();  
         
         while (nextItr != null && numChanges > 0) { 
            // Read data records with iterator                 
            GetRecordsResult getRecordsResult =  
               streamsClient.getRecords(new GetRecordsRequest(). 
               withShardIterator(nextItr));
               
            List<Record> records = getRecordsResult.getRecords(); 
            System.out.println("Pulling records...");  
               
            for (Record record : records) { 
               System.out.println(record); 
               numChanges--;
            } 
            nextItr = getRecordsResult.getNextShardIterator(); 
         } 
      } 
   } 
}

En cas d'échec du traitement d'une demande, DynamoDB renvoie une erreur. Chaque erreur se compose des éléments suivants: code d'état HTTP, nom d'exception et message. La gestion des erreurs repose sur votre SDK, qui propage les erreurs, ou sur votre propre code.

Codes et messages

Les exceptions appartiennent à différents codes d'état d'en-tête HTTP. Les 4xx et 5xx contiennent des erreurs liées aux problèmes de demande et à AWS.

Voici une sélection d'exceptions dans la catégorie HTTP 4xx -

AccessDeniedException - Le client n'a pas réussi à signer correctement la demande.
ConditionalCheckFailedException - Une condition évaluée à fausse.
IncompleteSignatureException - La demande comprenait une signature incomplète.

Les exceptions dans la catégorie HTTP 5xx sont les suivantes -

Erreur Interne du Serveur
Service indisponible

Nouvelles tentatives et algorithmes d'interruption

Les erreurs proviennent de diverses sources telles que des serveurs, des commutateurs, des équilibreurs de charge et d'autres éléments de structures et de systèmes. Les solutions courantes consistent en de simples tentatives, ce qui prend en charge la fiabilité. Tous les SDK incluent automatiquement cette logique et vous pouvez définir des paramètres de nouvelle tentative en fonction des besoins de votre application.

For example - Java propose une valeur maxErrorRetry pour arrêter les tentatives.

Amazon recommande d'utiliser une solution d'interruption en plus des tentatives afin de contrôler le flux. Cela consiste à augmenter progressivement les périodes d'attente entre les tentatives et à s'arrêter finalement après une période assez courte. Remarque Les SDK effectuent des tentatives automatiques, mais pas une interruption exponentielle.

Le programme suivant est un exemple d'interruption de nouvelle tentative -

public enum Results { 
   SUCCESS,  
   NOT_READY,  
   THROTTLED,  
   SERVER_ERROR 
}
public static void DoAndWaitExample() {  
   try {
      // asynchronous operation. 
      long token = asyncOperation();  
      int retries = 0; 
      boolean retry = false;  
      
      do { 
         long waitTime = Math.min(getWaitTime(retries), MAX_WAIT_INTERVAL);  
         System.out.print(waitTime + "\n");  
         
         // Pause for result 
         Thread.sleep(waitTime);  
         
         // Get result 
         Results result = getAsyncOperationResult(token);  
         
         if (Results.SUCCESS == result) { 
            retry = false; 
         } else if (Results.NOT_READY == result) { 
            retry = true; 
         } else if (Results.THROTTLED == result) { 
            retry = true; 
         } else if (Results.SERVER_ERROR == result) { 
            retry = true; 
         } else { 
            
            // stop on other error 
            retry = false; 
         }  
      } while (retry && (retries++ < MAX_RETRIES)); 
   }
   catch (Exception ex) { 
   } 
}
public static long getWaitTime(int retryCount) {  
   long waitTime = ((long) Math.pow(3, retryCount) * 100L);  
   return waitTime; 
}

Certaines pratiques optimisent le code, préviennent les erreurs et minimisent les coûts de débit lors de l'utilisation de diverses sources et éléments.

Voici quelques-unes des meilleures pratiques les plus importantes et les plus couramment utilisées dans DynamoDB.

les tables

La distribution des tableaux signifie que les meilleures approches répartissent uniformément l'activité de lecture / écriture sur tous les éléments du tableau.

Visez un accès uniforme aux données sur les éléments du tableau. L'utilisation optimale du débit repose sur la sélection de la clé primaire et les modèles de charge de travail des éléments. Répartissez uniformément la charge de travail sur les valeurs de clé de partition. Évitez des choses comme une petite quantité de valeurs de clé de partition très utilisées. Optez pour de meilleurs choix comme de grandes quantités de valeurs de clé de partition distinctes.

Acquérir une compréhension du comportement des partitions. Estimez les partitions automatiquement allouées par DynamoDB.

DynamoDB offre une utilisation du débit en rafale, qui réserve le débit inutilisé pour les «rafales» de puissance. Évitez une utilisation intensive de cette option car les rafales consomment rapidement de grandes quantités de débit; en outre, il ne constitue pas une ressource fiable.

Lors des téléchargements, distribuez les données afin d'obtenir de meilleures performances. Implémentez ceci en téléchargeant simultanément sur tous les serveurs alloués.

Mettez en cache les éléments fréquemment utilisés pour décharger l'activité de lecture vers le cache plutôt que vers la base de données.

Articles

La limitation, les performances, la taille et les coûts d'accès restent les principales préoccupations des articles. Optez pour des tables un-à-plusieurs. Supprimez les attributs et divisez les tables pour correspondre aux modèles d'accès. Vous pouvez améliorer considérablement l'efficacité grâce à cette approche simple.

Compressez les grandes valeurs avant de les stocker. Utilisez des outils de compression standard. Utilisez un stockage alternatif pour les valeurs d'attribut volumineuses telles que S3. Vous pouvez stocker l'objet dans S3 et un identifiant dans l'élément.

Distribuez de grands attributs sur plusieurs éléments via des éléments virtuels. Cela fournit une solution de contournement pour les limitations de taille d'élément.

Requêtes et analyses

Les requêtes et les analyses souffrent principalement de problèmes de consommation de débit. Évitez les rafales, qui résultent généralement de choses comme le passage à une lecture fortement cohérente. Utilisez des analyses parallèles avec peu de ressources (c'est-à-dire une fonction d'arrière-plan sans limitation). De plus, utilisez-les uniquement avec de grandes tables et les situations dans lesquelles vous n'utilisez pas pleinement le débit ou les opérations d'analyse offrent des performances médiocres.

Indices secondaires locaux

Les index présentent des problèmes dans les domaines du débit et des coûts de stockage, ainsi que de l'efficacité des requêtes. Évitez l'indexation, sauf si vous interrogez souvent les attributs. Dans les projections, choisissez judicieusement car ils gonflent les index. Sélectionnez uniquement ceux fortement utilisés.

Utilisez des index épars, c'est-à-dire des index dans lesquels les clés de tri n'apparaissent pas dans tous les éléments de table. Ils bénéficient des requêtes sur des attributs absents de la plupart des éléments de table.

Faites attention à l'expansion de la collection d'objets (tous les éléments de la table et leurs index). Les opérations d'ajout / de mise à jour entraînent une croissance des tables et des index, et 10 Go reste la limite pour les collections.

Indices secondaires mondiaux

Les index présentent des problèmes dans les domaines du débit et des coûts de stockage, ainsi que de l'efficacité des requêtes. Optez pour la répartition des attributs clés, qui, comme la répartition en lecture / écriture dans les tables, assure l'uniformité de la charge de travail. Choisissez des attributs qui répartissent uniformément les données. Utilisez également des index épars.

Exploitez les index secondaires globaux pour des recherches rapides dans les requêtes demandant une quantité modeste de données.