Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Fonctionnement d’Amazon DynamoDB
Les sections suivantes présentent les composants du service Amazon DynamoDB et leurs interactions.
**Topics**
+ [Aide-mémoire pour DynamoDB](CheatSheet.md)
+ [Composants de base d’Amazon DynamoDB](HowItWorks.CoreComponents.md)
+ [API DynamoDB](HowItWorks.API.md)
+ [Types de données et règles de dénomination pris en charge dans Amazon DynamoDB](HowItWorks.NamingRulesDataTypes.md)
+ [Classes de tables DynamoDB](HowItWorks.TableClasses.md)
+ [Partitions et distribution des données dans DynamoDB](HowItWorks.Partitions.md)
+ [Découvrez comment passer de SQL à NoSQL](SQLtoNoSQL.md)
+ [Ressources et outils de formation Amazon DynamoDB](AdditionalResources.md)
# Aide-mémoire pour DynamoDB
Ce aide-mémoire fournit une référence rapide pour travailler avec Amazon DynamoDB et ses différents outils. AWS SDKs
## Configuration initiale du
1. [Inscrivez-vous pour AWS](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.SignUpForAWS).
1. [Obtenez une clé d’accès AWS](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.GetCredentials) pour accéder à DynamoDB par programmation.
1. [Configurez vos informations d’identification DynamoDB](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.ConfigureCredentials).
**Voir aussi :**
+ [Configuration de DynamoDB (service web)](SettingUp.DynamoWebService.html)
+ [Mise en route avec DynamoDB](GettingStartedDynamoDB.html)
+ [Présentation de base des principaux composants](HowItWorks.CoreComponents.html)
## SDK ou CLI
Choisissez votre [SDK](sdk-general-information-section.html) préféré ou configurez l’[AWS CLI](/cli/latest/index.html).
**Note**
Lorsque vous utilisez AWS CLI le sous Windows, une barre oblique inversée (\$1) qui ne figure pas dans un devis est traitée comme un retour de transport. De plus, vous devez éviter les guillemets et les accolades à l’intérieur d’autres guillemets. À titre d’exemple, reportez-vous à l’onglet **Windows** dans « Create a table » (Créer une table) dans la section suivante.
**Voir aussi :**
+ [AWS CLI avec DynamoDB](Tools.CLI.html)
+ [Mise en route avec DynamoDB : étape 2](getting-started-step-2.html)
## Actions de base
Cette section fournit le code pour les tâches de base de DynamoDB. Pour plus d'informations sur ces tâches, consultez [Getting started with DynamoDB and the](GettingStarted.html). AWS SDKs
### Création d’une table
------
#### [ Default ]
```
aws dynamodb create-table \
--table-name Music \
--attribute-definitions \
AttributeName=Artist,AttributeType=S \
AttributeName=SongTitle,AttributeType=S \
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
--billing-mode PAY_PER_REQUEST \
--table-class STANDARD
```
------
#### [ Windows ]
```
aws dynamodb create-table ^
--table-name Music ^
--attribute-definitions ^
AttributeName=Artist,AttributeType=S ^
AttributeName=SongTitle,AttributeType=S ^
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE ^
--billing-mode PAY_PER_REQUEST ^
--table-class STANDARD
```
------
### Écrire un élément dans une table
```
aws dynamodb put-item \ --table-name Music \ --item file://item.json
```
### Lire un élément à partir d’une table
```
aws dynamodb get-item \ --table-name Music \ --item file://item.json
```
### Supprimer un élément d’une table
```
aws dynamodb delete-item --table-name Music --key file://key.json
```
### Interroger une table
```
aws dynamodb query --table-name Music
--key-condition-expression "ArtistName=:Artist and SongName=:Songtitle"
```
### Supprimer une table
```
aws dynamodb delete-table --table-name Music
```
### Répertorier le nom des tables
```
aws dynamodb list-tables
```
## Règles de dénomination
+ Tous les noms doivent être codés en UTF-8 et sont sensibles à la casse.
+ Les noms de table et les noms d’index doivent être compris entre 3 et 255 caractères, et peuvent contenir uniquement les caractères suivants :
+ `a-z`
+ `A-Z`
+ `0-9`
+ `_`(soulignement)
+ `-`(trait d’union)
+ `.`(point)
+ Un nom d’attribut doit compter au moins un caractère, mais ne peut pas avoir une taille supérieure à 64 Ko.
Pour plus d’informations, consultez les [règles de dénomination](HowItWorks.NamingRulesDataTypes.html).
## Principes de base des quotas de service
**Unités de lecture et d’écriture**
+ **RCU (Read capacity unit)** : une unité de capacité de lecture équivaut à une lecture fortement cohérente par seconde (ou à deux lectures éventuellement cohérentes par seconde) d’éléments dont la taille peut atteindre 4 Ko.
+ **WCU (Write capacity unit)** : Une unité de capacité d’écriture équivaut à une écriture par seconde d’éléments dont la taille peut atteindre 1 Ko.
**Limites liées aux tables**
+ **Taille de la table** : il n’existe pas de limite concrète de la taille d’une table. Les tables sont sans contraintes en ce qui concerne le nombre d’éléments ou le nombre d’octets.
+ **Nombre de tables** — Pour chaque AWS compte, il existe un quota initial de 2 500 tables par AWS région.
+ **Limite de taille de page pour les requêtes et les analyses** : la limite est de 1 Mo par page, par requête ou analyse. Si les paramètres de votre requête ou votre opération d’analyse sur une table génèrent plus de 1 Mo de données, DynamoDB renvoie les éléments correspondants initiaux. Il renvoie également une propriété `LastEvaluatedKey` que vous pouvez utiliser dans une nouvelle demande pour lire la page suivante.
**Index**
+ **Index secondaires locaux (LSIs)** — Vous pouvez définir un maximum de cinq index secondaires locaux. LSIs sont principalement utiles lorsqu'un index doit avoir une forte cohérence avec la table de base.
+ **Index secondaires globaux (GSIs)** : le quota par défaut est de 20 index secondaires globaux par table.
+ **Attributs d’index secondaire projeté par table** : vous pouvez projeter jusqu’à un total de 100 attributs dans l’ensemble des index secondaires locaux et globaux d’une table. Cette possibilité ne s’applique qu’aux attributs projetés spécifiés par l’utilisateur.
**Clé de partition**
+ La longueur minimale d’une valeur de clé de partition est 1 octet. La longueur maximale est de 2 048 octets.
+ Il n’existe pas de limite pratique quant au nombre de valeurs de clé de partition distinctes, pour les tables ou pour les index secondaires.
+ La longueur minimale d’une valeur de clé de tri est 1 octet. La longueur maximale est de 1 024 octets.
+ En général, il n’existe pas de limite pratique sur le nombre de valeurs de clé de tri distinctes par valeur de clé de partition. L’exception concerne les tables avec index secondaires.
Pour plus d’informations sur les index secondaires, ainsi que sur la conception des clés de partition et des clés de tri, consultez la section [Bonnes pratiques](best-practices.html).
**Limites applicables aux types de données couramment utilisés**
+ **Chaîne** : la longueur d’une chaîne est limitée par la taille maximum de l’élément, qui de 400 Ko. Les chaînes sont Unicode avec codage binaire UTF-8.
+ **Nombre** : un nombre peut avoir jusqu’à 38 chiffres de précision et peut être positif, négatif ou nul.
+ **Binaire** : la longueur d’un élément de type binaire est limitée par la taille maximum de l’élément, qui de 400 Ko. Les applications qui fonctionnent avec des attributs de type binaire doivent encoder les données au format base 64 avant de les envoyer à DynamoDB.
Pour afficher la liste complète des types de données pris en charge, consultez [Types de données](HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes). Pour de plus amples informations, veuillez également consulter [Quotas de service](ServiceQuotas.html#limits-items).
### Éléments, attributs et paramètres d’expression
La taille maximum d’un élément dans DynamoDB est de 400 Ko, ce qui comprend la longueur binaire du nom d’attribut (longueur UTF-8) et les longueurs binaires de valeur d’attribut (longueur UTF-8). Le nom d’attribut est comptabilisé parmi la limite de taille.
Il n’existe aucune limite au nombre de valeurs dans un élément de type List (liste), Map (mappage) ou Set (ensemble), pour autant que la taille de l’élément ne dépasse pas la talle limite de 400 Ko.
Pour les paramètres d’expression, la longueur maximale d’une chaîne d’expression est de 4 Ko.
Pour plus d’informations sur la taille des éléments, les attributs et les paramètres d’expression, consultez la section [Quotas de service](ServiceQuotas.html#limits-items).
## En savoir plus
+ [Sécurité](security.html)
+ [Surveillance et journalisation](monitoring.html)
+ [Utilisation des flux](streamsmain.html)
+ [Sauvegardes](Backup-and-Restore.html) et [Point-in-time restauration](Point-in-time-recovery.html)
+ [Intégration à d'autres AWS services](OtherServices.html)
+ [Référence d’API](/amazondynamodb/latest/APIReference/Welcome.html)
+ [Centre d’architecture : bonnes pratiques en matière de bases de données](https://aws.amazon.com/architecture/databases/)
+ [Didacticiels vidéo](https://youtu.be/Mw8wCj0gkRc)
+ [Forum DynamoDB](https://repost.aws/search/questions?globalSearch=dynamodb)
# Composants de base d’Amazon DynamoDB
Dans DynamoDB, les tables, les éléments et les attributs sont les principaux composants que vous utilisez. Une *table* est une collection d’*éléments* et chaque élément est une collection d’*attributs*. DynamoDB utilise des clés primaires afin d’identifier de façon unique chaque élément d’une table. Vous pouvez utiliser DynamoDB Streams pour récupérer les événements de modification des données dans des tables DynamoDB.
Il existe des limites dans DynamoDB. Pour de plus amples informations, veuillez consulter [Quotas dans Amazon DynamoDB](ServiceQuotas.md).
La vidéo suivante présente des tables, des éléments et des attributs.
[Tables, éléments et attributs](https://www.youtube.com/embed/Mw8wCj0gkRc)
## Tables, éléments et attributs
![\[Chaque table DynamoDB contient zéro ou plusieurs éléments composés d’un ou de plusieurs attributs.\]](http://docs.aws.amazon.com/fr_fr/amazondynamodb/latest/developerguide/images/HowItWorksTables-2024.png)
Voici les composants DynamoDB de base :
+ **Tables** – Comme d’autres systèmes de base de données, DynamoDB stocke les données dans des tables. Une *table* est un ensemble de données. Par exemple, consultez l’exemple de table appelée *People* que vous pouvez utiliser pour stocker les informations sur vos amis, votre famille ou toute autre personne de votre choix. Vous pouvez également avoir une table *Cars* pour stocker les informations sur les véhicules que les personnes conduisent.
+ **Eléments** – Chaque table contient zéro ou plusieurs éléments. Un *élément* est un groupe d’attributs identifiable de façon unique parmi tous les autres éléments. Dans une table *People*, chaque élément représente une personne. Pour une table *Cars*, chaque élément représente un véhicule. Les éléments dans DynamoDB sont similaires à maints égards aux lignes, registres ou tuples dans d’autres systèmes de base de données. Dans DynamoDB, il n’existe pas de limite au nombre d’éléments que vous pouvez stocker dans une table.
+ **Attributs** – Chaque élément se compose d’un ou de plusieurs attributs. Un *attribut* est un élément de donnée fondamental, qui n’a pas besoin d’être décomposé plus avant. Par exemple, un élément d'une table *People* contient des attributs appelés *PersonId *LastName**, *FirstName*,, etc. Pour une table *Department*, un élément peut avoir des attributs tels que *DepartmentID*, *Name*, *Manager*, etc. Les attributs dans DynamoDB sont similaires à maints égards à des champs ou colonnes dans d’autres systèmes de base de données.
Le schéma suivant montre une table nommée *Personnes* avec certains exemples d’éléments et d’attributs.
```
People
{
"PersonID": 101,
"LastName": "Smith",
"FirstName": "Fred",
"Phone": "555-4321"
}
{
"PersonID": 102,
"LastName": "Jones",
"FirstName": "Mary",
"Address": {
"Street": "123 Main",
"City": "Anytown",
"State": "OH",
"ZIPCode": 12345
}
}
{
"PersonID": 103,
"LastName": "Stephens",
"FirstName": "Howard",
"Address": {
"Street": "123 Main",
"City": "London",
"PostalCode": "ER3 5K8"
},
"FavoriteColor": "Blue"
}
```
Notez ce qui suit à propos de la table *Personnes* :
+ Chaque élément de la table possède un identifiant unique, ou clé primaire, qui distingue l’élément de tous les autres éléments de la table. Dans la table *Personnes*, la clé primaire se compose d’un seul attribut (*IDPersonne*).
+ En dehors de la clé primaire, la table *Personnes* est sans schéma, ce qui signifie que ni les attributs ni leurs types de données ne doivent être définis au préalable. Chaque élément peut avoir ses propres attributs distincts.
+ La plupart des attributs sont *scalaires*, ce qui signifie qu’ils ne peuvent avoir qu’une seule valeur. Les chaînes et les nombres sont des exemples courants de scalaires.
+ Certains éléments ont un attribut imbriqué (*Address*). DynamoDB prend en charge les attributs imbriqués jusqu’à 32 niveaux de profondeur.
Ce qui suit est un autre exemple de table nommée *Musique* que vous pouvez utiliser pour effectuer le suivi de votre collection musicale.
```
Music
{
"Artist": "No One You Know",
"SongTitle": "My Dog Spot",
"AlbumTitle": "Hey Now",
"Price": 1.98,
"Genre": "Country",
"CriticRating": 8.4
}
{
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road",
"AlbumTitle": "Somewhat Famous",
"Genre": "Country",
"CriticRating": 8.4,
"Year": 1984
}
{
"Artist": "The Acme Band",
"SongTitle": "Still in Love",
"AlbumTitle": "The Buck Starts Here",
"Price": 2.47,
"Genre": "Rock",
"PromotionInfo": {
"RadioStationsPlaying": [
"KHCR",
"KQBX",
"WTNR",
"WJJH"
],
"TourDates": {
"Seattle": "20150622",
"Cleveland": "20150630"
},
"Rotation": "Heavy"
}
}
{
"Artist": "The Acme Band",
"SongTitle": "Look Out, World",
"AlbumTitle": "The Buck Starts Here",
"Price": 0.99,
"Genre": "Rock"
}
```
Notez ce qui suit à propos de la table *Musique* :
+ La clé primaire de *Music* se compose de deux attributs (*Artiste* et *SongTitle*). Chaque élément de la table doit avoir ces deux attributs. La combinaison de *Artist* et C *SongTitle*distingue chaque élément du tableau de tous les autres.
+ En dehors de la clé primaire, la table *Musique* est sans schéma, ce qui signifie que ni les attributs ni leurs types de données ne doivent être définis au préalable. Chaque élément peut avoir ses propres attributs distincts.
+ L'un des éléments possède un attribut imbriqué (*PromotionInfo*), qui contient d'autres attributs imbriqués. DynamoDB prend en charge les attributs imbriqués jusqu’à 32 niveaux de profondeur.
Pour de plus amples informations, veuillez consulter [Utilisation de tables et de données dans DynamoDB](WorkingWithTables.md).
## Clé primaire
Lorsque vous créez une table, en plus du nom de la table, vous devez spécifier la clé primaire de la table. La clé primaire identifie de manière unique chaque élément de la table, afin qu’aucun deux éléments n’ait la même clé.
DynamoDB prend en charge deux genres de clés primaires :
+ **Clé de partition** – Clé primaire simple, composée d’un attribut nommé *clé de partition*.
DynamoDB utilise la valeur de la clé de partition comme entrée pour une fonction de hachage interne. La sortie de la fonction de hachage détermine la partition (stockage physique interne de DynamoDB) dans laquelle l’élément sera stocké.
Dans une table comportant une seule clé de partition, deux éléments d’une table ne peuvent pas avoir la même valeur de clé de partition.
La table *Personnes* décrite dans [Tables, éléments et attributs](#HowItWorks.CoreComponents.TablesItemsAttributes) est un exemple de table avec une clé primaire simple (*IDPersonne*). Vous pouvez accéder directement à n'importe quel élément du tableau *Personnes* en fournissant la *PersonId*valeur de cet élément.
+ **Clé de partition et clé de tri** – Appelée *clé primaire composite*, ce type de clé se compose de deux attributs. Le premier attribut est la *clé de partition* et le second attribut est la *clé de tri*.
DynamoDB utilise la valeur de clé de partition comme entrée pour une fonction de hachage interne. La sortie de la fonction de hachage détermine la partition (stockage physique interne de DynamoDB) dans laquelle l’élément sera stocké. Tous les éléments avec la même valeur de clé de partition sont stockés ensemble, par ordre de valeur de la clé de tri.
Dans une table comportant une clé de partition et une clé de tri, plusieurs éléments d’une table peuvent avoir la même valeur clé de partition. Toutefois, ces éléments doivent avoir des valeurs clé de tri différentes.
La table *Music* décrite dans [Tables, éléments et attributs](#HowItWorks.CoreComponents.TablesItemsAttributes) est un exemple de table dotée d'une clé primaire composite (*Artist* et *SongTitle*). Vous pouvez accéder directement à n'importe quel élément du tableau *Musique*, si vous indiquez l'*artiste* et *SongTitle*les valeurs de cet élément.
Une clé primaire composite vous offre plus de flexibilité lors de l’interrogation des données. Par exemple, si vous fournissez uniquement la valeur pour *Artiste*, DynamoDB extrait tous les morceaux de cet artiste. Pour récupérer uniquement un sous-ensemble de chansons d'un artiste en particulier, vous pouvez fournir une valeur pour *Artist* ainsi qu'une plage de valeurs pour *SongTitle*.
**Note**
La clé de partition d’un élément est également appelée *attribut de hachage*. L’expression *attribut de hachage* dérive de l’utilisation d’une fonction de hachage interne dans DynamoDB qui répartit uniformément les éléments de données entre les partitions, en fonction de leurs valeurs de clé de partition.
La clé de tri d’un élément est également appelée *attribut de plage*. L’expression *attribut de plage* dérive de la façon dont DynamoDB stocke des éléments ayant la même clé de partition à proximité physique les uns des autres, dans un ordre trié sur la valeur de clé de tri.
Chaque attribut de clé primaire doit être un scalaire (ce qui signifie qu’il ne peut contenir qu’une seule valeur). Les seuls types de données autorisés pour les attributs de clé primaires sont string, number ou binary. Il n’y a aucune restriction semblable pour les autres attributs non-clés.
## Index secondaires
Vous pouvez créer un ou plusieurs index secondaires sur une table. Un *index secondaire* vous permet d’interroger les données de la table à l’aide d’une clé alternative, en plus des requêtes sur la clé primaire. DynamoDB n’exige pas l’utilisation d’index, mais ceux-ci apportent à vos applications davantage de flexibilité pour l’interrogation des données. Une fois que vous avez créé un index secondaire sur une table, vous pouvez lire les données à partir de l’index de la même façon que vous le feriez à partir de la table.
DynamoDB prend en charge deux types d’index :
+ Index secondaire global – Index avec une clé de partition et une clé de tri pouvant différer de celles de la table. Les valeurs de clé primaire dans les index secondaires globaux ne doit pas nécessairement être uniques.
+ Index secondaire local – Index avec la même clé de partition que la table, mais une clé de tri différente.
Dans DynamoDB, les index secondaires globaux GSIs () sont des index qui s'étendent sur l'ensemble de la table, ce qui vous permet d'effectuer des requêtes sur toutes les clés de partition. Les index secondaires locaux (LSIs) sont des index qui ont la même clé de partition que la table de base mais une clé de tri différente.
Chaque table dans DynamoDB a un quota de 20 index secondaires globaux (quota par défaut) et de 5 index secondaires locaux.
Dans l'exemple de table *Music* présenté précédemment, vous pouvez interroger des éléments de données par *artiste* (clé de partition) ou par *artiste* et *SongTitle*(clé de partition et clé de tri). Et si vous vouliez également interroger les données par *genre* et *AlbumTitle*? Pour ce faire, vous pouvez créer un index sur *Genre *AlbumTitle**, puis interroger l'index de la même manière que vous interrogeriez la table *Music*.
Le schéma suivant montre l'exemple de table *musicale*, avec un nouvel index appelé *GenreAlbumTitle*. Dans l'index, *Genre* est la clé de partition et *AlbumTitle*la clé de tri.
| Table Music | *GenreAlbumTitle* |
| --- | --- |
|
{
"Artist": "No One You Know",
"SongTitle": "My Dog Spot",
"AlbumTitle": "Hey Now",
"Price": 1.98,
"Genre": "Country",
"CriticRating": 8.4
}
|
{
"Genre": "Country",
"AlbumTitle": "Hey Now",
"Artist": "No One You Know",
"SongTitle": "My Dog Spot"
}
|
|
{
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road",
"AlbumTitle": "Somewhat Famous",
"Genre": "Country",
"CriticRating": 8.4,
"Year": 1984
}
|
{
"Genre": "Country",
"AlbumTitle": "Somewhat Famous",
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road"
}
|
|
{
"Artist": "The Acme Band",
"SongTitle": "Still in Love",
"AlbumTitle": "The Buck Starts Here",
"Price": 2.47,
"Genre": "Rock",
"PromotionInfo": {
"RadioStationsPlaying": {
"KHCR",
"KQBX",
"WTNR",
"WJJH"
},
"TourDates": {
"Seattle": "20150622",
"Cleveland": "20150630"
},
"Rotation": "Heavy"
}
}
|
{
"Genre": "Rock",
"AlbumTitle": "The Buck Starts Here",
"Artist": "The Acme Band",
"SongTitle": "Still In Love"
}
|
|
{
"Artist": "The Acme Band",
"SongTitle": "Look Out, World",
"AlbumTitle": "The Buck Starts Here",
"Price": 0.99,
"Genre": "Rock"
}
|
{
"Genre": "Rock",
"AlbumTitle": "The Buck Starts Here",
"Artist": "The Acme Band",
"SongTitle": "Look Out, World"
}
|
Notez ce qui suit à propos de l'*GenreAlbumTitle*index :
+ Chaque index appartient à une table, qui est appelée la *table de base* de l’index. Dans l'exemple précédent, *Music* est la table de base de l'*GenreAlbumTitle*index.
+ DynamoDB tient à jour les index automatiquement. Lorsque vous ajoutez, mettez à jour ou supprimez un élément dans la table de base, DynamoDB ajoute, met à jour ou supprime l’élément correspondant dans les index appartenant à cette table.
+ Lorsque vous créez un index, vous spécifiez quels attributs seront copiés, ou *projetés*, depuis la table de base vers l’index. Au minimum, DynamoDB projette les attributs de clé de la table de base dans l’index. Tel est le cas avec `GenreAlbumTitle`, où seuls les attributs clés de la table `Music` sont projetés dans l’index.
Vous pouvez consulter l'*GenreAlbumTitle*index pour trouver tous les albums d'un genre donné (par exemple, tous les albums *Rock*). Vous pouvez également interroger l’index pour rechercher tous les albums dans un genre particulier avec certains titres d’album (par exemple, tous les albums *Country* dont les titres commencent par la lettre H).
Pour de plus amples informations, veuillez consulter [Amélioration de l’accès aux données avec les index secondaires dans DynamoDB](SecondaryIndexes.md).
## DynamoDB Streams
DynamoDB Streams est une fonction facultative qui récupère les événements de modification de données dans des tables DynamoDB. Les données sur ces événements apparaissent dans le flux de données presque en temps réel et dans l’ordre où les événements se sont produits.
Chaque événement est représenté par un *enregistrement de flux*. Si vous activez un flux sur une table, DynamoDB Streams écrit un registre de flux chaque fois que l’un des événements suivants se produit :
+ Un nouvel élément est ajouté à la table : le flux récupère une image de la totalité de l’élément, y compris l’ensemble de ses attributs.
+ Un élément est mis à jour : le flux capture l’image « avant » et « après » des attributs qui ont été modifiés dans l’élément.
+ Un élément est supprimé de la table : Le flux saisit une image de la totalité de l’élément avant qu’il n’ait été supprimé.
Chaque enregistrement de flux contient aussi le nom de la table, l’horodatage de l’événement et autres métadonnées. Les enregistrements de flux ont une durée de vie de 24 heures ; passé ce délai, ils sont automatiquement supprimés du flux.
Vous pouvez utiliser DynamoDB Streams conjointement AWS Lambda pour créer un *déclencheur*, c'est-à-dire un code qui s'exécute automatiquement chaque fois qu'un événement intéressant apparaît dans un flux. Par exemple, imaginons une table *Clients* qui contient les informations client d’une entreprise. Supposons que vous souhaitiez envoyer un e-mail de bienvenue à chaque nouveau client. Vous pouvez activer un flux sur cette table, puis associer le flux à une fonction Lambda. La fonction Lambda s’exécute chaque fois qu’un nouveau registre de flux apparaît, mais traite uniquement les nouveaux éléments ajoutés à la table *Customers*. Pour tout élément ayant un attribut `EmailAddress`, la fonction Lambda appelle Amazon Simple Email Service (Amazon SES) pour envoyer un e-mail à cette adresse.
![\[Intégration de DynamoDB Streams et de Lambda pour envoyer automatiquement un e-mail de bienvenue aux nouveaux clients.\]](http://docs.aws.amazon.com/fr_fr/amazondynamodb/latest/developerguide/images/HowItWorksStreams.png)
**Note**
Dans cet exemple, le dernier client, Craig Roe, ne reçoit pas d’e-mail, car il n’a pas d’attribut `EmailAddress`.
Outre les déclencheurs, DynamoDB Streams propose des solutions puissantes telles que la réplication de données au sein des AWS régions et entre celles-ci, les vues matérialisées des données dans des tables DynamoDB, l'analyse des données à l'aide de vues matérialisées Kinesis, et bien plus encore.
Pour de plus amples informations, veuillez consulter [Modifier la récupération de données pour DynamoDB Streams](Streams.md).
# API DynamoDB
Pour opérer avec Amazon DynamoDB, votre application doit utiliser quelques opérations d’API simples. Voici un résumé de ces opérations, classées par catégorie.
**Note**
Pour obtenir la liste complète des opérations d’API, consultez la [Référence API Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/Welcome.html).
**Topics**
+ [Plan de contrôle](#HowItWorks.API.ControlPlane)
+ [Plan de données](#HowItWorks.API.DataPlane)
+ [DynamoDB Streams](#HowItWorks.API.Streams)
+ [Transactions](#HowItWorks.API.Transactions)
## Plan de contrôle
Les opérations de *plan de contrôle* vous permettent de créer et gérer des tables DynamoDB. Elles vous permettent également d’utiliser les index, les flux et autres objets qui dépendent des tables.
+ `CreateTable` – Crée une table. Vous pouvez créer un ou plusieurs index secondaires, puis activer DynamoDB Streams pour la table.
+ `DescribeTable` – Retourne des informations sur une table, telles que son schéma de clé primaire, ses paramètres de débit et ses informations d’index.
+ `ListTables` – Renvoie les noms de toutes vos tables dans une liste.
+ `UpdateTable` – Modifie les paramètres d’une table ou de ses index, crée ou supprime de nouveaux index sur une table, ou modifie les paramètres DynamoDB Streams d’une table.
+ `DeleteTable` – Supprime une table et tous ses objets dépendants de DynamoDB.
## Plan de données
Les opérations de *plan de données* vous permettent d’exécuter les opérations de création, lecture, mise à jour et suppression (également appelées opérations *CRUD*) sur les données d’une table. Certaines opérations de plan de données vous permettent également de lire les données d’un index secondaire.
Vous pouvez utiliser[PartiQL – Langage de requête compatible SQL pour Amazon DynamoDB](ql-reference.md), pour effectuer ces opérations CRUD, ou vous pouvez utiliser le CRUD classique de DynamoDB APIs qui sépare chaque opération en un appel d'API distinct.
### PartiQL – Langage de requête compatible SQL
+ `ExecuteStatement` – Lit plusieurs éléments d’une table. Vous pouvez également écrire ou mettre à jour un élément unique à partir d’une table. Lors de l’écriture ou de la mise à jour d’un élément unique, vous devez spécifier les attributs de clé primaire.
+ `BatchExecuteStatement` – Ecrit, met à jour ou lit plusieurs éléments d’une table. Cette solution est plus efficace que l’opération `ExecuteStatement` parce que votre application n’a besoin que d’un seul aller-retour réseau pour lire les éléments.
### classique APIs
#### Création de données
+ `PutItem` – Ecrit un élément unique dans une table. Vous devez spécifier les attributs de clé primaire, mais vous n’avez pas à spécifier d’autres attributs.
+ `BatchWriteItem` – Ecrit jusqu’à 25 éléments dans une table. Cette solution est plus efficace que l’appel répété de `PutItem` parce que votre application a uniquement besoin d’un seul aller-retour réseau pour écrire les éléments.
#### Lecture de données
+ `GetItem` – Extrait un élément unique d’une table. Vous devez spécifier la clé primaire de l’élément que vous voulez. Vous pouvez récupérer l’élément entier ou juste un sous-ensemble de ses attributs.
+ `BatchGetItem` – Extrait jusqu’à 100 éléments d’une ou de plusieurs tables. Cette solution est plus efficace que l’appel répété de `GetItem` parce que votre application a uniquement besoin d’un seul aller-retour réseau pour lire les éléments.
+ `Query` – Extrait tous les éléments ayant une clé de partition spécifique. Vous devez spécifier la valeur de la clé de partition. Vous pouvez récupérer des éléments entiers, ou juste un sous-ensemble de leurs attributs. Le cas échéant, vous pouvez appliquer une condition aux valeurs de clé de tri, afin de récupérer uniquement un sous-ensemble des données ayant la même clé de partition. Vous pouvez utiliser cette opération sur une table, à condition que la table ait une clé de partition et une clé de tri. Vous pouvez également utiliser cette opération sur un index, à condition que l’index ait une clé de partition et une clé de tri.
+ `Scan` – Extrait tous les éléments de la table ou de l’index spécifiés. Vous pouvez récupérer des éléments entiers, ou juste un sous-ensemble de leurs attributs. Le cas échéant, vous pouvez appliquer une condition de filtre pour renvoyer uniquement les valeurs qui vous intéressent et ignorer les autres.
#### Mise à jour de données
+ `UpdateItem` – Modifie un ou plusieurs attributs dans un élément. Vous devez spécifier la clé primaire de l’élément que vous voulez modifier. Vous pouvez ajouter de nouveaux attributs et modifier ou supprimer des attributs existants. Vous pouvez également effectuer des mises à jour conditionnelles, afin que la mise à jour ne réussisse que lorsqu’une condition définie par l’utilisateur est remplie. Le cas échéant, vous pouvez mettre en place un compteur atomique, qui augmente ou diminue un attribut numérique sans interférer avec d’autres demandes d’écriture.
#### Suppression des données
+ `DeleteItem` – Supprime un élément unique d’une table. Vous devez spécifier la clé primaire de l’élément que vous voulez supprimer.
+ `BatchWriteItem` – Supprime jusqu’à 25 éléments d’une ou de plusieurs tables. Cette solution est plus efficace que l’appel répété de `DeleteItem` parce que votre application a uniquement besoin d’un seul aller-retour réseau pour supprimer les éléments.
**Note**
Vous pouvez utiliser `BatchWriteItem` pour créer des données et supprimer des données.
## DynamoDB Streams
Les opérations *DynamoDB Streams* vous permettent d’activer ou de désactiver un flux sur une table, et d’autoriser l’accès aux registres de modification de données contenus dans un flux.
+ `ListStreams` – Retourne la liste de tous vos flux, ou simplement le flux d’une table spécifique.
+ `DescribeStream` – Retourne des informations sur un flux, telles que son Amazon Resource Name (ARN) et l’emplacement où votre application peut commencer à lire les tout premiers registres de flux.
+ `GetShardIterator` – Retourne un *itérateur de partition*, c’est-à-dire une structure de données que votre application utilise pour extraire les registres du flux.
+ `GetRecords` – Récupère un ou plusieurs registres de flux à l’aide d’un itérateur de partition donné.
## Transactions
Les *transactions* offrent atomicité, cohérence, isolation et durabilité (ACID), ce qui permet de maintenir plus facilement l’exactitude des données dans vos applications.
Vous pouvez utiliser[PartiQL – Langage de requête compatible SQL pour Amazon DynamoDB](ql-reference.md), pour effectuer des opérations transactionnelles, ou vous pouvez utiliser le CRUD classique de DynamoDB APIs qui sépare chaque opération en un appel d'API distinct.
### PartiQL – Langage de requête compatible SQL
+ `ExecuteTransaction`— Une opération par lots qui permet d'effectuer des opérations CRUD sur plusieurs éléments à la fois dans et entre les tables avec un all-or-nothing résultat garanti.
### classique APIs
+ `TransactWriteItems`— Une opération par lots qui permet d'`Put``Update`effectuer des `Delete` opérations sur plusieurs éléments à la fois dans et entre les tables avec un all-or-nothing résultat garanti.
+ `TransactGetItems` – Opération par lot qui permet d’effectuer des opérations `Get` pour extraire plusieurs éléments d’une ou de plusieurs tables.
# Types de données et règles de dénomination pris en charge dans Amazon DynamoDB
Cette section décrit les règles de dénomination dans Amazon DynamoDB, ainsi les différents types de données que DynamoDB prend en charge. Des limites s’appliquent aux types de données. Pour de plus amples informations, veuillez consulter [Types de données](Constraints.md#limits-data-types).
**Topics**
+ [Règles de dénomination](#HowItWorks.NamingRules)
+ [Types de données](#HowItWorks.DataTypes)
+ [Descripteurs de type de données](#HowItWorks.DataTypeDescriptors)
## Règles de dénomination
Les tables, attributs et autres objets dans DynamoDB doivent avoir des noms. Les noms doivent être éloquents et concis. Par exemple, des noms tels que *Produits*, *Livres* et *Auteurs* sont explicites.
Voici les règles de dénomination pour DynamoDB.
+ Tous les noms doivent être codés à l’aide d’UTF-8 et sont sensibles à la casse.
+ Les noms de table et les noms d’index doivent être compris entre 3 et 255 caractères, et peuvent contenir uniquement les caractères suivants :
+ `a-z`
+ `A-Z `
+ ` 0-9 `
+ `_` (soulignement)
+ `-` (tiret)
+ `.` (point)
+ Un nom d’attribut doit compter au moins un caractère, mais sa taille doit être inférieure à 64 Ko. Une bonne pratique consiste à utiliser des noms d’attribut aussi courts que possible. Cela permet de réduire le nombre d’unités de demande de lecture consommées, car les noms d’attributs sont inclus dans la mesure du stockage et de l’utilisation de débit.
Les éléments suivants sont les exceptions. Ces noms d’attribut ne doivent pas dépasser 255 caractères :
+ Noms de clés de partition d’index secondaire
+ Noms de clés de tri d’index secondaire
+ Noms d’attributs projetés spécifiés par l’utilisateur (applicables uniquement aux index secondaires locaux)
### Mots réservés et caractères spéciaux
DynamoDB comprend une liste de mots réservés et de caractères spéciaux. Pour obtenir la liste complète, consultez [Mots réservés dans DynamoDB](ReservedWords.md). Les caractères suivants ont également une signification spéciale dans DynamoDB : **\$1** (dièse) et **:** (deux points).
Même si DynamoDB vous permet d’utiliser ces mots réservés et ces caractères spéciaux pour les noms, nous vous recommandons d’éviter de le faire, car vous devez définir les variables d’espace réservé chaque fois que vous utilisez ces noms dans une expression. Pour de plus amples informations, veuillez consulter [Noms d’attributs d’expression (alias) dans DynamoDB](Expressions.ExpressionAttributeNames.md).
## Types de données
DynamoDB prend en charge différents types de données pour les attributs au sein d’une table. Ils peuvent être classés comme suit :
+ **Types scalar (scalaire)** – Un type scalar peut représenter exactement une valeur. Les types scalar sont les suivants : number, string, binary, Boolean et null.
+ **Types document** – Un type document peut représenter une structure complexe constituée d’attributs imbriqués, comme vous pouvez en trouver dans un document JSON. Les types document sont les suivants : list et map.
+ **Types set (ensemble)** – Un type set peut représenter plusieurs valeurs scalaires. Les types set sont les suivants : string set, number set et binary set.
Lorsque vous créez une table ou un index secondaire, vous devez spécifier les noms et les types de données de chaque attribut de clé primaire (clé de partition et clé de tri). En outre, chaque attribut de clé primaire doit être défini en tant que type string, number ou binary (chaîne, nombre ou binaire).
DynamoDB est une base de données NoSQL et est *sans schéma*. Cela signifie que, en dehors des attributs de clé primaire, vous n’avez pas besoin de définir d’attributs ou de types de données lorsque vous créez des tables. En comparaison, vous devez, pour les bases de données relationnelles, définir les noms et les types de données de chaque colonne lorsque vous créez une table.
Les descriptions suivantes concernent chaque type de données, ainsi que des exemples au format JSON.
### Types scalar
Les types scalar sont les suivants : number, string, binary, Boolean et null.
#### Number
Les nombres peuvent être positifs, négatifs ou nuls. La précision maximum des nombres est de 38 chiffres. Tout dépassement entraîne une exception. Si vous avez besoin d’une précision supérieure à 38 chiffres, vous pouvez utiliser des chaînes.
+ Plage positive : 1E-130 à 9,9999999999999999999999999999999999999E\$1125
+ Plage négative : -9,9999999999999999999999999999999999999E\$1125 à -1E-130
Dans DynamoDB, les nombres sont représentés en tant que longueur variable. Les zéros de début et de fin sont tronqués.
Tous les nombres sont envoyés à DynamoDB via le réseau sous forme de chaînes afin d’optimiser la compatibilité entre les langages et les bibliothèques. Toutefois, DynamoDB les traite en tant qu’attributs de type number (nombre) pour les opérations mathématiques.
Vous pouvez utiliser le type de données number pour représenter une date ou un horodatage. Une façon de procéder consiste à utiliser l’heure epoch, à savoir le nombre de secondes depuis le 1er janvier 1970 à 00:00:00 UTC. Par exemple, l’heure Posix `1437136300` correspond au 17 juillet 2015, 12:31:40 UTC.
Pour plus d'informations, consultez [http://en.wikipedia. org/wiki/Unix\$1heure.](http://en.wikipedia.org/wiki/Unix_time)
#### String
Les chaînes sont Unicode avec codage binaire UTF-8. La longueur minimale d’une chaîne peut être zéro si l’attribut n’est pas utilisé comme clé pour un index ou une table, et est contrainte par la limite de taille d’élément de 400 Ko dans DynamoDB.
Les contraintes supplémentaires suivantes s’appliquent aux attributs de clé primaire définis comme type string (chaîne) :
+ Pour une clé primaire unique, la longueur maximale de la première valeur d’attribut (la clé de partition) est de 2 048 octets.
+ Pour une clé primaire composite, la longueur maximale de la deuxième valeur d’attribut (la clé de tri) est de 1 024 octets.
DynamoDB collationne et compare les chaînes à l’aide des octets de l’encodage de chaîne UTF-8 sous-jacent. Par exemple, « `a` » (0x61) est supérieur à « `A` » (0x41) et « `¿` » (0xC2BF) est supérieur à « `z` » (0x7A).
Vous pouvez utiliser le type de données string pour représenter une date ou un horodatage. Une solution pour cela consiste à utiliser les chaînes ISO 8601, comme illustré dans ces exemples :
+ `2016-02-15`
+ `2015-12-21T17:42:34Z`
+ `20150311T122706Z`
Pour plus d'informations, consultez [http://en.wikipedia. org/wiki/ISO\$18601](http://en.wikipedia.org/wiki/ISO_8601).
**Note**
Contrairement aux bases de données relationnelles classiques, DynamoDB ne prend pas en charge de manière native un type de données de date et d’heure. Il peut être utile de stocker les données et les données temporelles sous forme de type de données numériques, en utilisant le temps d’époque Unix.
#### Binaire
Les attributs de type binary peuvent stocker n’importe quelle donnée binaire, telle que texte compressé, données chiffrées ou images. Chaque fois que DynamoDB compare des valeurs binaires, il traite chaque octet de données binaires comme non signé.
La longueur d’un binary attribute peut être zéro si l’attribut n’est pas utilisé comme clé pour un index ou une table, et est contrainte par la limite de taille d’élément de 400 Ko dans DynamoDB.
Si vous définissez un attribut de clé primaire comme attribut de type binary (binaire), les contraintes supplémentaires suivantes s’appliquent :
+ Pour une clé primaire unique, la longueur maximale de la première valeur d’attribut (la clé de partition) est de 2 048 octets.
+ Pour une clé primaire composite, la longueur maximale de la deuxième valeur d’attribut (la clé de tri) est de 1 024 octets.
Vos applications doivent encoder les valeurs binaires dans un format encodé en base 64 avant de les envoyer à DynamoDB. À la réception de ces valeurs, DynamoDB les décode dans un tableau d’octets non signés, et utilise ces informations comme longueur du binary attribute.
L’exemple suivant est un binary attribute, utilisant un texte codé en base64.
```
dGhpcyB0ZXh0IGlzIGJhc2U2NC1lbmNvZGVk
```
#### Booléen
Un attribut de type Boolean peut stocker `true` ou `false`.
#### Null
Null représente un attribut avec un état inconnu ou non défini.
### Types document
Les types document sont les suivants : list et map. Ces types de données peuvent être imbriqués les uns dans les autres pour représenter des structures de données complexes jusqu’à 32 niveaux de profondeur.
Il n’existe aucune limite au nombre de valeurs dans un élément de type list (liste) ou map (mappage), pour autant que la taille de l’élément ne dépasse pas la limite de taille d’élément en vigueur dans DynamoDB (400 Ko).
Une valeur d’attribut peut être une chaîne vide ou une valeur binaire vide si l’attribut n’est pas utilisé pour une clé de table ou d’index. Une valeur d’attribut ne peut pas être un jeu vide (jeu de chaînes, jeu de chiffres ou jeu binaire). Cependant, les listes et les cartes vides sont autorisées. Les valeurs binaires et de chaînes vides sont autorisées dans les listes et les cartes. Pour de plus amples informations, veuillez consulter [Attributes](Constraints.md#limits-attributes).
#### List
Un attribut de type list peut stocker une collection ordonnée de valeurs. Les types list sont entourés de crochets :`[ ... ]`
Une liste est similaire à un tableau JSON. Il n’y a aucune restriction sur les types de données qui peuvent être stockés dans un élément de type list et les éléments d’un élément de type list n’ont pas à être du même type.
L’exemple suivant montre une liste contenant deux chaînes et un nombre.
```
FavoriteThings: ["Cookies", "Coffee", 3.14159]
```
**Note**
DynamoDB vous permet d’utiliser des éléments individuels dans des listes, même si ces éléments sont profondément imbriqués. Pour de plus amples informations, veuillez consulter [Utilisation d’expressions dans DynamoDB](Expressions.md).
#### Map
Un attribut de type map peut stocker une collection non ordonnée de paires nom-valeur. Les types map sont placés entre accolades : `{ ... }`
Un type map est similaire à un objet JSON. Il n’y a aucune restriction sur les types de données qui peuvent être stockés dans un élément de type map et les éléments d’un élément de type map n’ont pas à être du même type.
Les éléments de type map sont idéaux pour stocker des documents JSON dans DynamoDB. L’exemple suivant montre un élément de type map qui contient une chaîne, un nombre et une liste imbriquée contenant un autre élément de type map.
```
{
Day: "Monday",
UnreadEmails: 42,
ItemsOnMyDesk: [
"Coffee Cup",
"Telephone",
{
Pens: { Quantity : 3},
Pencils: { Quantity : 2},
Erasers: { Quantity : 1}
}
]
}
```
**Note**
DynamoDB vous permet d’utiliser des éléments individuels dans des mappages, même si ces éléments sont profondément imbriqués. Pour de plus amples informations, veuillez consulter [Utilisation d’expressions dans DynamoDB](Expressions.md).
### Sets
DynamoDB prend en charge des types représentant des ensembles de valeurs de type string (chaîne), number (nombre) ou binary (binaire). Tous les éléments au sein d’un ensemble doivent être du même type. Par exemple, un Number Set peut contenir uniquement des nombres, et un String Set peut contenir uniquement des chaînes.
Il n’existe aucune limite au nombre de valeurs dans un élément de type set (ensemble), pour autant que la taille de l’élément ne dépasse pas la limite de taille d’élément en vigueur dans DynamoDB (400 Ko).
Chaque valeur au sein d’un ensemble doit être unique. L’ordre des valeurs d’un ensemble n’est pas conservé. Par conséquent, vos applications ne doivent pas reposer sur un ordre particulier des éléments au sein de l’ensemble. DynamoDB ne prend pas en charge les ensembles vides. Cependant, des valeurs de type string (chaîne) et binary (binaire) vides sont autorisées dans un ensemble.
L’exemple suivant illustre un ensemble de chaînes, un ensemble de nombres et un ensemble de données binaires :
```
["Black", "Green", "Red"]
[42.2, -19, 7.5, 3.14]
["U3Vubnk=", "UmFpbnk=", "U25vd3k="]
```
## Descripteurs de type de données
Le protocole d’API DynamoDB de bas niveau utilise des *descripteurs de type de données* comme jetons qui indiquent à DynamoDB comment interpréter chaque attribut.
La liste suivante est la liste complète des descripteurs de type de données DynamoDB :
+ **`S`** – String (chaîne)
+ **`N`** – Number (nombre)
+ **`B`** – Binary (binaire)
+ **`BOOL`** – Boolean (booléen)
+ **`NULL`** – Null
+ **`M`** – Map (mappage)
+ **`L`** – List (liste)
+ **`SS`** – String Set (ensemble de chaînes)
+ **`NS`** – Number Set (ensemble de nombres)
+ **`BS`** – Binary Set (ensemble de binaires)
# Classes de tables DynamoDB
DynamoDB propose deux classes de tables conçues pour vous aider à optimiser vos coûts. La classe de tables DynamoDB Standard est la classe par défaut. Elle est recommandée pour la grande majorité des charges de travail. La classe de tables DynamoDB Standard-Infrequent Access (DynamoDB Standard-IA) est optimisée pour les tables où le stockage est le coût dominant. Par exemple, les tables qui stockent des données rarement consultées, telles que les journaux d’applications, les anciennes publications sur les réseaux sociaux, l’historique des commandes d’e-commerce et les exploits de jeux passés, sont de bons candidats pour la classe de tables Standard-IA. Pour plus de détails sur la tarification, consultez [Tarification Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/on-demand/).
Chaque table DynamoDB est associée à une classe de tables (DynamoDB Standard par défaut). Tous les index secondaires associés à la table utilisent la même classe de table. Chaque classe de tables offre une tarification différente pour le stockage des données ainsi que pour les demandes de lecture et d’écriture. Vous pouvez sélectionner la classe de tables la plus rentable pour votre table en fonction de ses modèles de stockage et d’utilisation du débit.
Le choix d'une classe de table n'est pas permanent. Vous pouvez modifier ce paramètre à l'aide de la AWS Management Console AWS CLI ou du SDK. AWS DynamoDB prend également en charge la gestion de votre classe de table à AWS CloudFormation l'aide de tables à région unique et de tables globales. Pour en savoir plus sur la sélection de votre classe de tables, consultez [Points à prendre en considération lors du choix d’une classe de tables dans DynamoDB](WorkingWithTables.tableclasses.md).
# Partitions et distribution des données dans DynamoDB
Amazon DynamoDB stocke les données dans des partitions. Une *partition* est une allocation de stockage pour une table, soutenue par des disques SSD (SSDs) et répliquée automatiquement sur plusieurs zones de disponibilité au sein d'une AWS région. La gestion des partitions étant entièrement effectuée par DynamoDB, vous n’avez jamais besoin de vous en occuper.
Lorsque vous créez une table, l’état initial de la table est `CREATING`. Au cours de cette phase, DynamoDB alloue à la table des partitions en nombre suffisant pour qu’elle puisse gérer vos exigences de débit approvisionné. Vous pouvez commencer à écrire et à lire les données de table une fois que l’état de la table est devenu `ACTIVE`.
DynamoDB alloue des partitions supplémentaires à une table dans les cas suivants :
+ Si vous augmentez les paramètres de débit alloué de la table au-delà de ce que les partitions existantes peuvent prendre en charge.
+ Si la capacité d’une partition existante est pleine et qu’un espace de stockage supplémentaire est obligatoire.
La gestion de la partition s’effectue automatiquement à l’arrière-plan et est transparente pour vos applications. Votre table reste disponible tout au long et prend entièrement en charge vos besoins de débit alloué.
Pour en savoir plus, consultez [Création de clés de partition](bp-partition-key-design.md).
Des index secondaires globaux dans DynamoDB sont également composés de partitions. Les données d’un index secondaire global sont stockées séparément des données de sa table de base, mais les partitions d’index se comportent de la même manière que les partitions de table.
## Distribution de données : clé de partition
Si votre table possède une clé primaire simple (clé de partition uniquement), DynamoDB stocke et récupère chaque élément en fonction de sa valeur de clé de partition.
Pour écrire un élément dans la table, DynamoDB utilise la valeur de la clé de partition comme entrée pour une fonction de hachage interne. La valeur de sortie de la fonction de hachage détermine la partition dans laquelle l’élément sera stocké.
Pour lire un élément de la table, vous devez spécifier sa valeur de clé de partition. DynamoDB utilise cette valeur comme entrée pour sa fonction de hachage, donnant la partition dans laquelle se trouve l’élément.
Le schéma suivant montre une table nommée *Animaux de compagnie*, qui s’étend sur plusieurs partitions. La clé primaire de la table est *AnimalType*(seul cet attribut clé est affiché). DynamoDB utilise sa fonction de hachage pour déterminer où stocker un nouvel élément, en l’occurrence, en fonction de la valeur de hachage de la chaîne *Dog*. Notez que les éléments ne sont pas stockés selon un ordre trié. L’emplacement de chaque élément est déterminé par la valeur de hachage de sa clé de partition.
![\[Distribution par DynamoDB des éléments de table entre les partitions en fonction de la valeur de hachage de la clé de partition.\]](http://docs.aws.amazon.com/fr_fr/amazondynamodb/latest/developerguide/images/HowItWorksPartitionKey.png)
**Note**
DynamoDB est optimisé pour une distribution uniforme des éléments entre les partitions d’une table, quel que soit le nombre de partitions. Nous vous conseillons de choisir une clé de partition qui peut avoir un grand nombre de valeurs distinctes par rapport au nombre d’éléments de la table.
## Distribution de données : clé de partition et clé de tri
Si la table possède une clé primaire composite (clé de partition et clé de tri), DynamoDB calcule la valeur de hachage de la clé de partition de la manière décrite dans [Distribution de données : clé de partition](#HowItWorks.Partitions.SimpleKey). Cependant, il a tendance à conserver les éléments ayant la même valeur de clé de partition proches les uns des autres et triés en fonction de la valeur de l’attribut de la clé de tri. L’ensemble des éléments qui ont la même valeur de clé de partition est nommé collection d’éléments. Les collections d’éléments sont optimisées pour assurer une extraction efficace des gammes d’éléments dans la collection. Si votre table ne possède pas d’index secondaires locaux, DynamoDB répartit automatiquement votre collection d’éléments sur autant de partitions que nécessaire pour stocker les données et optimiser le débit de lecture et d’écriture.
Pour écrire un élément dans la table, DynamoDB calcule la valeur de hachage de la clé de partition pour déterminer quelle partition doit contenir l’élément. Dans cette partition, plusieurs éléments peuvent avoir la même valeur de clé de partition. Ainsi, DynamoDB stocke l’élément parmi les autres éléments possédant la même clé de partition, dans l’ordre croissant de la clé de tri.
Pour lire un élément dans la table, vous devez spécifier les valeurs de ses clés de partition et de tri. DynamoDB calcule la valeur de hachage de la clé de partition, donnant la partition dans laquelle se trouve l’élément.
Vous pouvez lire plusieurs éléments de la table en une seule opération (`Query`) si les éléments souhaités ont la même valeur de clé de partition. DynamoDB renvoie tous les éléments ayant cette valeur de clé de partition. Le cas échéant, vous pouvez appliquer une condition à la clé de tri afin qu’elle retourne uniquement les éléments d’une plage de valeurs donnée.
Supposons que la table *Pets* possède une clé primaire composite composée de *AnimalType*(clé de partition) et de *nom* (clé de tri). Le diagramme suivant montre DynamoDB écrivant un élément avec une valeur de clé de partition *Dog* et une valeur de clé de tri *Fido*.
![\[DynamoDB stocke un élément avec une clé de partition composite et le trie en fonction de la valeur de l’attribut de clé de tri.\]](http://docs.aws.amazon.com/fr_fr/amazondynamodb/latest/developerguide/images/HowItWorksPartitionKeySortKey.png)
Pour lire cet élément dans la table *Pets*, DynamoDB calcule la valeur de hachage de *Dog*, donnant la partition dans laquelle ces éléments sont stockés. DynamoDB analyse ensuite les valeurs d’attribut de clé de tri jusqu’à trouver *Fido*.
Pour lire tous les éléments marqués *AnimalType*d'un *Dog*, vous pouvez effectuer une `Query` opération sans spécifier de condition de clé de tri. Par défaut, les éléments sont retournés dans l’ordre où ils sont stockés (c’est-à-dire, en ordre croissant par clé de tri). Le cas échéant, vous pouvez demander à la place l’ordre décroissant.
Pour interroger uniquement certains éléments *Chien*, vous pouvez appliquer une condition à la clé de tri (par exemple, seuls les éléments *Chien* où *Nom* commence par une lettre située dans la plage `A` à `K`).
**Note**
Dans une table DynamoDB, il n’existe pas de limite supérieure au nombre de valeurs de clé de tri distinctes par valeur de clé de partition. Si vous avez besoin de stocker plusieurs milliards d’éléments *Dog* dans la table *Pets*, DynamoDB alloue automatiquement un stockage suffisant pour gérer cette exigence.
# Découvrez comment passer de SQL à NoSQL
Si vous êtes développeur d’applications, il se peut que vous ayez une certaine expérience concernant l’utilisation d’un système de gestion de base de données relationnelle (SGBDR) et d’un langage de recherche structurée (SQL). Lorsque vous commencerez à utiliser le service Amazon DynamoDB, vous constaterez qu’il présente bon nombre de similitudes mais aussi de différences par rapport à SQL. *NoSQL* est un terme utilisé pour décrire les systèmes de base de données non relationnelle qui sont hautement disponibles, évolutifs et optimisés pour des performances élevées. Au lieu du modèle relationnel, les bases de données NoSQL (comme DynamoDB) utilisent d’autres modèles pour la gestion des données, tels que les paires clé-valeur ou le stockage de documents. Pour plus d’informations, veuillez consulter [Présentation de NoSQL](https://aws.amazon.com/nosql).
Amazon DynamoDB prend en charge [PartiQL](https://partiql.org/), un langage de requête open source compatible SQL qui vous permet d’interroger les données facilement et de manière efficace, quel que soit leur emplacement ou format de stockage. Avec PartiQL, vous pouvez facilement traiter des données structurées à partir de bases de données relationnelles, des données semi-structurées et imbriquées dans des formats de données ouvertes, et même des données sans schéma dans NoSQL ou des bases de données document qui autorisent différents attributs pour différentes lignes. Pour plus d’informations, consultez [Langage de requête PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html).
Les sections suivantes décrivent les tâches courantes de base de données, en comparant les instructions SQL et leurs opérations DynamoDB équivalentes.
**Note**
Les exemples SQL de cette section sont compatibles avec le SGBDR MySQL.
Les exemples DynamoDB dans cette section affichent le nom de l’opération DynamoDB, ainsi que ses paramètres au format JSON.
**Topics**
+ [Choix entre système relationnel (SQL) et NoSQL](SQLtoNoSQL.WhyDynamoDB.md)
+ [Différences entre l’accès à une base de données relationnelle (SQL) et à DynamoDB](SQLtoNoSQL.Accessing.md)
+ [Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la création d’une table](SQLtoNoSQL.CreateTable.md)
+ [Différences entre l’obtention d’informations sur une table à partir d’une base de données relationnelle (SQL) et de DynamoDB](SQLtoNoSQL.GetTableInfo.md)
+ [Différences entre une base de données relationnelle (SQL) et DynamoDB lors de l’écriture de données dans une table](SQLtoNoSQL.WriteData.md)
+ [Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la lecture de données à partir d’une table](SQLtoNoSQL.ReadData.md)
+ [Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la gestion d’index](SQLtoNoSQL.Indexes.md)
+ [Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la modification de données dans une table](SQLtoNoSQL.UpdateData.md)
+ [Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la suppression de données dans une table](SQLtoNoSQL.DeleteData.md)
+ [Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la suppression d’une table](SQLtoNoSQL.RemoveTable.md)
# Choix entre système relationnel (SQL) et NoSQL
Aujourd’hui, les applications ont des besoins plus exigeants que par le passé. Par exemple, un jeu en ligne peut démarrer avec quelques utilisateurs seulement et une très petite quantité de données. Cependant, si le jeu devient un succès, il peut facilement dépasser les ressources du système de gestion de la base de données sous-jacente. Il est fréquent que les applications web aient des centaines, des milliers ou des millions d’utilisateurs simultanés, avec des téraoctets ou plus de nouvelles données générées par jour. Les bases de données de telles applications doivent gérer des dizaines (voire des centaines) de milliers de lectures et d’écritures par seconde.
Amazon DynamoDB convient parfaitement à ces types de charges de travail. En tant que développeur, vous pouvez commencer à petite échelle et augmenter progressivement votre utilisation au fur et à mesure que votre application gagne en popularité. DynamoDB se met à l’échelle en toute transparence pour gérer un très grand nombre d’utilisateurs et des quantités considérables de données.
Pour en savoir plus sur la modélisation des bases de données relationnelles traditionnelles et sur la façon de l’adapter à DynamoDB, consultez [Bonnes pratiques de modélisation des données relationnelles dans DynamoDB](bp-relational-modeling.md).
Le tableau suivant présente quelques différences générales entre un système de gestion de base de données relationnelle (SGBDR) et DynamoDB.
****
| Caractéristiques | Système de gestion de base de données relationnelle (SGBDR) | Amazon DynamoDB |
| --- | --- | --- |
| Charges de travail optimales | Requêtes ad hoc ; entreposage de données ; traitement analytique en ligne (OLAP). | Applications web, y compris les réseaux sociaux, les jeux, le partage des fichiers multimédia et l’Internet des objets (IoT). |
| Modèle de données | Le modèle relationnel nécessite un schéma bien défini, dans lequel les données sont normalisées en tables, lignes et colonnes. De plus, toutes les relations sont définies entre tables, colonnes, index et autres éléments de base de données. | DynamoDB est sans schéma. Chaque table doit avoir une clé primaire pour identifier de façon unique chaque élément de données, mais aucune contrainte similaire ne s’applique aux attributs autres que de clé. DynamoDB peut gérer des données structurées ou semi-structurées, y compris des documents JSON. |
| Accès aux données | SQL constitue la norme pour le stockage et la récupération de données. Les bases de données relationnelles offrent un riche ensemble d’outils pour simplifier le développement d’applications de base de données, mais tous ces outils utilisent SQL. | Vous pouvez utiliser le AWS Management Console AWS CLI, le ou NoSQL WorkBench pour travailler avec DynamoDB et effectuer des tâches ad hoc. [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un langage de requête compatible SQL, vous permet de sélectionner, d’insérer, de mettre à jour et de supprimer des données dans DynamoDB. Les applications peuvent utiliser les kits de développement AWS logiciel (SDKs) pour travailler avec DynamoDB à l'aide d'interfaces basées sur des objets, centrées sur le document ou de bas niveau. |
| Performances | Les bases de données relationnelles étant optimisées pour le stockage, les performances dépendent généralement du sous-système du disque. Les développeurs et les administrateurs de base de données doivent optimiser les requêtes, les index et les structures de table afin d’atteindre des performances de pointe. | DynamoDB étant optimisé pour le calcul, les performances dépendent principalement du matériel sous-jacent et de la latence réseau. En tant que service géré, DynamoDB vous dispense, ainsi que vos applications, de ces détails d’implémentation, si bien que vous pouvez vous concentrer sur la conception et la génération d’applications robustes hautement performantes. |
| Dimensionnement | Il est plus facile d’agrandir avec un matériel plus rapide. Il est également possible pour les tables de base de données de s’étendre sur plusieurs hôtes d’un système distribué, mais cela nécessite des investissements supplémentaires. Les bases de données relationnelles possèdent une taille maximale pour le nombre de fichiers et leur taille, ce qui impose des limites supérieures sur l’évolutivité. | DynamoDB est conçu pour monter en charge à l’aide de clusters distribués de matériel. Cette conception permet un débit accru sans augmentation de la latence. Les clients spécifient leurs exigences de débit et DynamoDB alloue des ressources suffisantes pour répondre à ces exigences. Il n’y a aucune limite supérieure sur le nombre d’éléments par table, ni sur la taille totale de la table. |
# Différences entre l’accès à une base de données relationnelle (SQL) et à DynamoDB
Avant que votre application puise accéder à une base de données, elle doit être *authentifiée* pour garantir que l’application est autorisée à utiliser la base de données. Elle doit être *autorisée* de manière à ce que l’application ne puisse effectuer que les actions pour lesquelles elle possède des autorisations.
Le schéma suivant illustre l’interaction d’un client avec une base de données relationnelle et avec Amazon DynamoDB.
![\[Interaction avec les bases de données relationnelles et NoSQL\]](http://docs.aws.amazon.com/fr_fr/amazondynamodb/latest/developerguide/images/SQLtoNoSQL.png)
Le tableau suivant propose plus d’informations sur les tâches liées à l’interaction client.
****
| Caractéristiques | Système de gestion de base de données relationnelle (SGBDR) | Amazon DynamoDB |
| --- | --- | --- |
| Outils pour accéder à la base de données | La plupart des bases de données relationnelles offrent une interface de ligne de commande (CLI), de telle sorte que vous pouvez saisir des instructions SQL ad hoc et observer les résultats immédiatement. | Dans la plupart des cas, vous écrivez le code de l’application. Vous pouvez également utiliser le Workbench AWS Management Console, the AWS Command Line Interface (AWS CLI) ou NoSQL pour envoyer des requêtes ad hoc à DynamoDB et afficher les résultats. [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un langage de requête compatible SQL, vous permet de sélectionner, d’insérer, de mettre à jour et de supprimer des données dans DynamoDB. |
| Connexion à la base de données | Un programme d’application établit et gère une connexion réseau avec la base de données. Lorsque l’application est terminée, il met fin à la connexion. | DynamoDB est un service web, et les interactions avec celui-ci sont sans état. Les applications n’ont pas besoin de maintenir des connexions réseau permanentes. Au lieu de cela, l’interaction avec DynamoDB se produit via des requêtes et réponses HTTP(S). |
| Authentification | Une application ne peut pas se connecter à la base de données tant qu’elle n’est pas authentifiée. Le SGBDR peut effectuer l’authentification lui-même ou déléguer cette tâche au système d’exploitation hôte ou à un service d’annuaire. | Chaque demande adressée à DynamoDB doit être accompagnée d’une signature de chiffrement qui authentifie cette demande particulière. Ils AWS SDKs fournissent toute la logique nécessaire pour créer des signatures et des demandes de signature. Pour plus d'informations, consultez [la section Signature des demandes d' AWS API](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) dans le Références générales AWS. |
| Autorisation | Les applications ne peuvent exécuter que les actions pour lesquelles elles sont autorisées. Les administrateurs de base de données ou les propriétaires d’applications peuvent utiliser les instructions SQL GRANT et REVOKE pour contrôler l’accès aux objets de base de données (tels que les tables) et aux données (telles que les lignes d’une table), ou la possibilité d’émettre certaines instructions SQL. | Dans DynamoDB, l'autorisation est gérée Gestion des identités et des accès AWS par (IAM). Vous pouvez écrire une politique IAM pour accorder des autorisations sur une ressource DynamoDB (telle une table), puis autoriser des utilisateurs et des rôles à utiliser cette politique. IAM offre également un contrôle précis des accès pour les éléments de données individuels dans les tables DynamoDB. Pour de plus amples informations, veuillez consulter [Gestion des identités et des accès pour Amazon DynamoDB](security-iam.md). |
| Envoi d’une demande | L’application émet une instruction SQL pour chaque opération de base de données qu’elle souhaite effectuer. À la réception de l’instruction SQL, le SGBDR vérifie sa syntaxe, crée un plan pour effectuer l’opération, puis exécute le plan. | L’application envoie des requêtes HTTP(S) à DynamoDB. Une requête contient le nom de l’opération DynamoDB à effectuer, ainsi que les paramètres de celle-ci. DynamoDB exécute la requête immédiatement. |
| Réception d’une réponse | Le SGBDR retourne les résultats de l’instruction SQL. S’il y a une erreur, le SGBDR retourne un statut d’erreur et un message. | DynamoDB renvoie une réponse HTTP(S) contenant les résultats de l’opération. En cas d’erreur, DynamoDB renvoie un état et des messages d’erreur HTTP. |
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la création d’une table
Les tables sont les structures de données fondamentales dans les bases de données relationnelles et dans Amazon DynamoDB. Un système de gestion de base de données relationnelles (SGBDR) vous permet de définir le schéma de la table lorsque vous la créez. En revanche, les tables DynamoDB sont sans schéma. Lorsque vous créez une table, en dehors de la clé primaire, vous n’avez pas besoin de définir d’attributs ou de types de données supplémentaires.
La section suivante compare la méthode de création d’une table avec SQL d’une part et avec DynamoDB d’autre part.
**Topics**
+ [Création d’une table avec SQL](#SQLtoNoSQL.CreateTable.SQL)
+ [Création d’une table avec DynamoDB](#SQLtoNoSQL.CreateTable.DynamoDB)
## Création d’une table avec SQL
Avec SQL, la création d’une table s’effectue via l’instruction `CREATE TABLE`, comme le montre l’exemple suivant.
```
CREATE TABLE Music (
Artist VARCHAR(20) NOT NULL,
SongTitle VARCHAR(30) NOT NULL,
AlbumTitle VARCHAR(25),
Year INT,
Price FLOAT,
Genre VARCHAR(10),
Tags TEXT,
PRIMARY KEY(Artist, SongTitle)
);
```
La clé primaire de cette table comprend *Artist* et *SongTitle*.
Vous devez définir toutes les colonnes de la table et leurs types de données, ainsi que la clé primaire de la table. (Vous pouvez utiliser l’instruction `ALTER TABLE` pour modifier ces définitions ultérieurement, si nécessaire.)
De nombreuses implémentations SQL vous permettent de définir les spécifications de stockage de votre table, dans le cadre de l’instruction `CREATE TABLE`. Sauf spécification contraire, la table est créée avec les paramètres de stockage par défaut. Dans un environnement de production, un administrateur de base de données peut aider à déterminer les paramètres de stockage optimaux.
## Création d’une table avec DynamoDB
Utilisez l’opération `CreateTable` pour créer une table en mode alloué, en spécifiant les paramètres comme suit :
```
{
TableName : "Music",
KeySchema: [
{
AttributeName: "Artist",
KeyType: "HASH" //Partition key
},
{
AttributeName: "SongTitle",
KeyType: "RANGE" //Sort key
}
],
AttributeDefinitions: [
{
AttributeName: "Artist",
AttributeType: "S"
},
{
AttributeName: "SongTitle",
AttributeType: "S"
}
],
ProvisionedThroughput: { // Only specified if using provisioned mode
ReadCapacityUnits: 1,
WriteCapacityUnits: 1
}
}
```
La clé primaire de cette table est composée de *Artist* (clé de partition) et *SongTitle*(clé de tri).
Vous devez fournir les paramètres suivants à `CreateTable` :
+ `TableName` – Nom de la table.
+ `KeySchema` – Attributs utilisés pour la clé primaire. Pour plus d’informations, consultez [Tables, éléments et attributs](HowItWorks.CoreComponents.md#HowItWorks.CoreComponents.TablesItemsAttributes) et [Clé primaire](HowItWorks.CoreComponents.md#HowItWorks.CoreComponents.PrimaryKey).
+ `AttributeDefinitions` – Types de données pour les attributs du schéma de clé.
+ `ProvisionedThroughput (for provisioned tables)` – Nombre de lectures et d’écritures par seconde nécessaires pour cette table. DynamoDB réserve suffisamment de ressources de stockage et système pour que vos besoins de débit soient toujours satisfaits. Vous pouvez utiliser l’opération `UpdateTable` pour modifier ces éléments ultérieurement, si nécessaire. Vous n’avez pas besoin de spécifier les besoins de stockage d’une table, car DynamoDB gère entièrement l’allocation du stockage.
# Différences entre l’obtention d’informations sur une table à partir d’une base de données relationnelle (SQL) et de DynamoDB
Vous pouvez vérifier qu’une table a été créée selon vos spécifications. Dans une base de données relationnelle, la totalité du schéma de la table est affiché. Les tables Amazon DynamoDB étant sans schéma, seuls les attributs de clé primaire sont affichés.
**Topics**
+ [Obtention d’informations sur une table avec SQL](#SQLtoNoSQL.GetTableInfo.SQL)
+ [Obtention d’informations sur une table dans DynamoDB](#SQLtoNoSQL.GetTableInfo.DynamoDB)
## Obtention d’informations sur une table avec SQL
La plupart des systèmes de gestion de base de données relationnelle (SGBDR) permettent de décrire la structure d’une table : colonnes, types de données, définition de clé primaire, etc. Il n’existe aucune méthode standard pour ce faire dans SQL. Cependant, beaucoup de systèmes de base de données offrent une commande `DESCRIBE`. Voici un exemple de fichier de MySQL :
```
DESCRIBE Music;
```
Cette commande renvoie la structure de votre table, avec l’ensemble des noms de colonnes, types de données et tailles.
```
+------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+------------+-------------+------+-----+---------+-------+
| Artist | varchar(20) | NO | PRI | NULL | |
| SongTitle | varchar(30) | NO | PRI | NULL | |
| AlbumTitle | varchar(25) | YES | | NULL | |
| Year | int(11) | YES | | NULL | |
| Price | float | YES | | NULL | |
| Genre | varchar(10) | YES | | NULL | |
| Tags | text | YES | | NULL | |
+------------+-------------+------+-----+---------+-------+
```
La clé primaire de cette table comprend *Artist* et *SongTitle*.
## Obtention d’informations sur une table dans DynamoDB
DynamoDB intègre une opération `DescribeTable`, qui est similaire. Le seul paramètre requis est le nom de la table.
```
{
TableName : "Music"
}
```
La réponse de `DescribeTable` se présente ainsi :
```
{
"Table": {
"AttributeDefinitions": [
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "SongTitle",
"AttributeType": "S"
}
],
"TableName": "Music",
"KeySchema": [
{
"AttributeName": "Artist",
"KeyType": "HASH" //Partition key
},
{
"AttributeName": "SongTitle",
"KeyType": "RANGE" //Sort key
}
],
...
```
`DescribeTable` renvoie également des informations sur les index de la table, les paramètres de débit alloué, le nombre approximatif d’éléments et d’autres métadonnées.
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de l’écriture de données dans une table
Les tables des bases de données relationnelles contiennent des *lignes* de données. Les lignes sont composées de *colonnes*. Les tables Amazon DynamoDB contiennent des *éléments*. Les éléments sont composés d’*attributs*.
Cette section décrit comment écrire une ligne (ou un élément) dans une table.
**Topics**
+ [Écriture de données dans une table avec SQL](#SQLtoNoSQL.WriteData.SQL)
+ [Écrire de données dans une table dans DynamoDB](#SQLtoNoSQL.WriteData.DynamoDB)
## Écriture de données dans une table avec SQL
Une table d’une base de données relationnelle est une structure de données à deux dimensions, composée de lignes et de colonnes. Certains systèmes de gestion de base de données fournissent également la prise en charge des données semi-structurées, généralement avec les types de données natifs JSON ou XML. Cependant, les détails de la mise en œuvre varient selon les fournisseurs.
En SQL, l’ajout d’une ligne à une table s’effectue via l’instruction `INSERT`.
```
INSERT INTO Music
(Artist, SongTitle, AlbumTitle,
Year, Price, Genre,
Tags)
VALUES(
'No One You Know', 'Call Me Today', 'Somewhat Famous',
2015, 2.14, 'Country',
'{"Composers": ["Smith", "Jones", "Davis"],"LengthInSeconds": 214}'
);
```
La clé primaire de cette table comprend *Artist* et *SongTitle*. Vous devez spécifier les valeurs de ces colonnes.
**Note**
Cet exemple utilise la colonne *Tags* pour stocker les données semi-structurées sur les chansons de la table *Music*. La colonne *Tags* est définie au format TEXTE, ce qui permet de stocker jusqu’à 65 535 caractères dans MySQL.
## Écrire de données dans une table dans DynamoDB
Dans Amazon DynamoDB, vous pouvez ajouter un élément à une table à l’aide de l’API DynamoDB ou de [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (langage de requête compatible SQL).
------
#### [ DynamoDB API ]
Avec l’API DynamoDB, vous utilisez l’opération `PutItem` pour ajouter un élément à une table.
```
{
TableName: "Music",
Item: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today",
"AlbumTitle":"Somewhat Famous",
"Year": 2015,
"Price": 2.14,
"Genre": "Country",
"Tags": {
"Composers": [
"Smith",
"Jones",
"Davis"
],
"LengthInSeconds": 214
}
}
}
```
La clé primaire de cette table comprend *Artist* et *SongTitle*. Vous devez spécifier les valeurs de ces attributs.
Voici quelques éléments clés à savoir sur cet exemple `PutItem` :
+ DynamoDB assure une prise en charge native des documents à l’aide de JSON. Cela fait de DynamoDB un outil idéal pour stocker des données semi-structurées telles que des *étiquettes*. Vous pouvez également récupérer et manipuler les données à partir des documents JSON.
+ La table *Music* ne possède aucun attribut prédéfini, à l'exception de la clé primaire (*Artist* et *SongTitle*).
+ La plupart des bases de données SQL sont orientées transactions. Lorsque vous émettez une instruction `INSERT`, les modifications des données ne sont pas permanentes jusqu’à ce que vous lanciez une instruction `COMMIT`. Avec Amazon DynamoDB, les effets d’une opération `PutItem` sont permanents lorsque DynamoDB répond par un code d’état HTTP 200 (`OK`).
Voici quelques autres exemples de `PutItem`.
```
{
TableName: "Music",
Item: {
"Artist": "No One You Know",
"SongTitle": "My Dog Spot",
"AlbumTitle":"Hey Now",
"Price": 1.98,
"Genre": "Country",
"CriticRating": 8.4
}
}
```
```
{
TableName: "Music",
Item: {
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road",
"AlbumTitle":"Somewhat Famous",
"Genre": "Country",
"CriticRating": 8.4,
"Year": 1984
}
}
```
```
{
TableName: "Music",
Item: {
"Artist": "The Acme Band",
"SongTitle": "Still In Love",
"AlbumTitle":"The Buck Starts Here",
"Price": 2.47,
"Genre": "Rock",
"PromotionInfo": {
"RadioStationsPlaying":[
"KHCR", "KBQX", "WTNR", "WJJH"
],
"TourDates": {
"Seattle": "20150625",
"Cleveland": "20150630"
},
"Rotation": "Heavy"
}
}
}
```
```
{
TableName: "Music",
Item: {
"Artist": "The Acme Band",
"SongTitle": "Look Out, World",
"AlbumTitle":"The Buck Starts Here",
"Price": 0.99,
"Genre": "Rock"
}
}
```
**Note**
En plus de `PutItem`, DynamoDB prend en charge une opération `BatchWriteItem` pour écrire plusieurs éléments à la fois.
------
#### [ PartiQL for DynamoDB ]
Avec PartiQL, vous utilisez l’opération `ExecuteStatement` pour ajouter un élément à une table, à l’aide de l’instruction PartiQL `Insert`.
```
INSERT into Music value {
'Artist': 'No One You Know',
'SongTitle': 'Call Me Today',
'AlbumTitle': 'Somewhat Famous',
'Year' : '2015',
'Genre' : 'Acme'
}
```
La clé primaire de cette table comprend *Artist* et *SongTitle*. Vous devez spécifier les valeurs de ces attributs.
**Note**
Pour des exemples de code utilisant `Insert` et `ExecuteStatement`, consultez [Instructions d’insertion de PartiQL pour DynamoDB](ql-reference.insert.md).
------
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la lecture de données à partir d’une table
Avec SQL, vous utilisez l’instruction `SELECT` pour extraire une ou plusieurs lignes d’une table. Vous utilisez la clause `WHERE` pour déterminer les données qui vous sont renvoyées.
Cela est différent d’Amazon DynamoDB, qui propose les opérations suivantes pour la lecture de données :
+ `ExecuteStatement` récupère un ou plusieurs éléments d’une table. `BatchExecuteStatement` récupère plusieurs éléments de tables différentes en une seule opération. Ces deux opérations utilisent [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un langage de requête compatible SQL.
+ `GetItem` – Extrait un élément unique d’une table. C’est le moyen le plus efficace de lire un élément unique, car il fournit un accès direct à l’emplacement physique de l’élément. (DynamoDB fournit également l’opération `BatchGetItem` permettant d’effectuer jusqu’à 100 appels `GetItem` en une seule opération.)
+ `Query` – Extrait tous les éléments ayant une clé de partition spécifique. Au sein de ces éléments, vous pouvez appliquer une condition à la clé de tri et récupérer uniquement un sous-ensemble des données. `Query` fournit un accès rapide et efficace aux partitions où les données sont stockées. (Pour plus d’informations, consultez [Partitions et distribution des données dans DynamoDB](HowItWorks.Partitions.md).)
+ `Scan` – Extrait tous les éléments de la table spécifiée. (Cette opération ne doit pas être utilisée avec les grandes tables, car elle peut consommer d’importantes quantités de ressources système.)
**Note**
Avec une base de données relationnelle, vous pouvez utiliser l’instruction `SELECT` pour joindre les données de plusieurs tables et retourner les résultats. Les jointures sont fondamentales pour le modèle relationnel. Pour garantir l’efficacité des jointures, les performances de la base de données et de ses applications doivent être ajustées en permanence. DynamoDB est une base de données NoSQL non relationnelle qui ne prend pas en charge les jointures de tables. Au lieu de cela, les applications lisent les données d’une seule table à la fois.
Les sections suivantes décrivent les différents cas d’utilisation de lecture des données et comment exécuter ces tâches avec une base de données relationnelle et avec DynamoDB.
**Topics**
+ [Différences dans la lecture d’un élément à l’aide de sa clé primaire](SQLtoNoSQL.ReadData.SingleItem.md)
+ [Différences dans l’interrogation d’une table](SQLtoNoSQL.ReadData.Query.md)
+ [Différences dans l’analyse d’une table](SQLtoNoSQL.ReadData.Scan.md)
# Différences dans la lecture d’un élément à l’aide de sa clé primaire
Un modèle d’accès commun aux bases de données consiste à lire un seul élément d’une table. Vous devez spécifier la clé primaire de l’élément que vous voulez.
**Topics**
+ [Lecture d’un élément à partir de sa clé primaire avec SQL](#SQLtoNoSQL.ReadData.SingleItem.SQL)
+ [Lecture d’un élément à partir de sa clé primaire dans DynamoDB](#SQLtoNoSQL.ReadData.SingleItem.DynamoDB)
## Lecture d’un élément à partir de sa clé primaire avec SQL
En SQL, l’extraction de données d’une table s’effectue à l’aide de l’instruction `SELECT`. Vous pouvez demander une ou plusieurs colonnes du résultat (ou la totalité, si vous utilisez l’opération `*`). La clause `WHERE` détermine les lignes à retourner.
L’instruction `SELECT` suivante permet d’extraire une seule ligne de la table *Music*. La clause `WHERE` spécifie les valeurs de clé primaire.
```
SELECT *
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```
Vous pouvez modifier cette requête pour récupérer uniquement un sous-ensemble des colonnes.
```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```
Notez que la clé primaire de ce tableau est composée de *Artist* et *SongTitle*.
## Lecture d’un élément à partir de sa clé primaire dans DynamoDB
Dans Amazon DynamoDB, vous pouvez lire un élément à partir d’une table à l’aide de l’API DynamoDB ou de [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (langage de requête compatible SQL).
------
#### [ DynamoDB API ]
Avec l’API DynamoDB, vous utilisez l’opération `PutItem` pour ajouter un élément à une table.
DynamoDB propose l’opération `GetItem` pour extraire un élément à partir de sa clé primaire. L’opération `GetItem` est très efficace, car elle donne directement accès à l’emplacement physique de l’élément. (Pour plus d’informations, consultez [Partitions et distribution des données dans DynamoDB](HowItWorks.Partitions.md).)
Par défaut, `GetItem` retourne l’élément entier avec tous ses attributs.
```
{
TableName: "Music",
Key: {
"Artist": "No One You Know",
"SongTitle": "Call Me Today"
}
}
```
Vous pouvez ajouter un paramètre `ProjectionExpression` pour renvoyer uniquement certains des attributs.
```
{
TableName: "Music",
Key: {
"Artist": "No One You Know",
"SongTitle": "Call Me Today"
},
"ProjectionExpression": "AlbumTitle, Year, Price"
}
```
Notez que la clé primaire de ce tableau est composée de *Artist* et *SongTitle*.
L’opération `GetItem` de DynamoDB est très efficace. Elle utilise les valeurs de clé primaire pour déterminer l’emplacement exact de stockage de l’élément en question et le récupère directement de cet emplacement. L’instruction SQL `SELECT` est efficace de la même façon, en ce qui concerne la récupération d’éléments par valeurs de clé primaire.
L’instruction SQL `SELECT` prend en charge de nombreux types de requêtes et d’analyses de table. DynamoDB propose une fonctionnalité similaire avec ses opérations `Query` et `Scan`, qui sont décrites dans [Différences dans l’interrogation d’une table](SQLtoNoSQL.ReadData.Query.md) et [Différences dans l’analyse d’une table](SQLtoNoSQL.ReadData.Scan.md).
L’instruction SQL `SELECT` permet d’effectuer des jointures de tables, ce qui vous permet de récupérer les données de plusieurs tables à la fois. Les jointures sont plus efficaces lorsque les tables de base de données sont normalisées et que les relations entre les tables sont claires. Toutefois, si vous joignez un trop grand nombre de tables dans une instruction `SELECT`, les performances de l’application peuvent en être affectées. Vous pouvez contourner ces problèmes en utilisant la réplication de base de données, les vues matérialisées ou les réécritures de requête.
DynamoDB est une base de données non relationnelle ne prenant pas en charge les jointures de tables. Si vous migrez une application existante à partir d’une base de données relationnelle vers DynamoDB, vous devez dénormaliser votre modèle de données pour éliminer la nécessité de jointures.
------
#### [ PartiQL for DynamoDB ]
Avec PartiQL, vous utilisez l’opération `ExecuteStatement` pour lire un élément d’une table, à l’aide de l’instruction PartiQL `Select`.
```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```
Notez que la clé primaire de ce tableau est composée de Artist et SongTitle.
**Note**
L’instruction PartiQL select permet également d’interroger ou d’analyser une table DynamoDB
Pour des exemples de code utilisant `Select` et `ExecuteStatement`, consultez [Instructions PartiQL de sélection pour DynamoDB](ql-reference.select.md).
------
# Différences dans l’interrogation d’une table
Un autre modèle commun d’accès est la lecture de plusieurs éléments d’une table, selon les critères de votre requête.
**Topics**
+ [Interrogation d’une table avec SQL](#SQLtoNoSQL.ReadData.Query.SQL)
+ [Interrogation d’une table dans DynamoDB](#SQLtoNoSQL.ReadData.Query.DynamoDB)
## Interrogation d’une table avec SQL
Lorsque vous utilisez SQL, l’instruction `SELECT` vous permet d’interroger les colonnes clé, les colonnes non-clé ou toute autre combinaison. La clause `WHERE` détermine quelles lignes sont retournées, comme illustré dans les exemples suivants.
```
/* Return a single song, by primary key */
SELECT * FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today';
```
```
/* Return all of the songs by an artist */
SELECT * FROM Music
WHERE Artist='No One You Know';
```
```
/* Return all of the songs by an artist, matching first part of title */
SELECT * FROM Music
WHERE Artist='No One You Know' AND SongTitle LIKE 'Call%';
```
```
/* Return all of the songs by an artist, only if the price is less than 1.00 */
SELECT * FROM Music
WHERE Artist='No One You Know'
AND Price < 1.00;
```
Notez que la clé primaire de ce tableau est composée de *Artist* et *SongTitle*.
## Interrogation d’une table dans DynamoDB
Dans Amazon DynamoDB, vous pouvez interroger un élément à partir d’une table à l’aide de l’API DynamoDB ou de [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (langage de requête compatible SQL).
------
#### [ DynamoDB API ]
Avec Amazon DynamoDB, vous pouvez utiliser l’opération `Query` pour extraire des données de façon similaire. L’opération `Query` fournit un accès rapide et efficace aux emplacements physiques où sont stockées les données. Pour de plus amples informations, veuillez consulter [Partitions et distribution des données dans DynamoDB](HowItWorks.Partitions.md).
Vous pouvez utiliser `Query` avec n’importe quel(le) table ou index secondaire. Vous devez spécifier une condition d’égalité pour la valeur de la clé de partition et, le cas échéant, fournir une autre condition pour l’attribut de la clé de tri s’il est défini.
Le paramètre `KeyConditionExpression` spécifie les valeurs clés que vous souhaitez interroger. Vous pouvez utiliser un paramètre `FilterExpression` facultatif pour supprimer des résultats certains éléments avant qu’ils ne vous soient retournés.
Dans DynamoDB, vous devez utiliser des `ExpressionAttributeValues` comme espaces réservés dans des paramètres d’expression (tels que `KeyConditionExpression` et `FilterExpression`). C’est analogue à l’utilisation des *variables de liaison* des bases de données relationnelles, où vous remplacez les valeurs réelles dans l’instruction `SELECT` au moment de l’exécution.
Notez que la clé primaire de ce tableau est composée de *Artist* et *SongTitle*.
Voici quelques exemples d’actions `Query` de DynamoDB.
```
// Return a single song, by primary key
{
TableName: "Music",
KeyConditionExpression: "Artist = :a and SongTitle = :t",
ExpressionAttributeValues: {
":a": "No One You Know",
":t": "Call Me Today"
}
}
```
```
// Return all of the songs by an artist
{
TableName: "Music",
KeyConditionExpression: "Artist = :a",
ExpressionAttributeValues: {
":a": "No One You Know"
}
}
```
```
// Return all of the songs by an artist, matching first part of title
{
TableName: "Music",
KeyConditionExpression: "Artist = :a and begins_with(SongTitle, :t)",
ExpressionAttributeValues: {
":a": "No One You Know",
":t": "Call"
}
}
```
```
// Return all of the songs by an artist, only if the price is less than 1.00
{
TableName: "Music",
KeyConditionExpression: "Artist = :a",
FilterExpression: "Price < :p",
ExpressionAttributeValues: {
":a": "No One You Know",
":p": 1.00
}
}
```
**Note**
A `FilterExpression` est appliqué après les `Query` lectures des éléments correspondants, il ne réduit donc pas la capacité de lecture consommée. Dans la mesure du possible, modélisez vos données de manière à ce que les conditions de plage `KeyConditionExpression` soient utilisées sur la clé de tri pour des requêtes efficaces. Pour de plus amples informations, veuillez consulter [Interrogation de tables dans DynamoDB](Query.md).
------
#### [ PartiQL for DynamoDB ]
Avec PartiQL, vous pouvez exécuter une requête en utilisant l’opération `ExecuteStatement` et l’instruction `Select` sur la clé de partition.
```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know'
```
Une telle utilisation de l’instruction `SELECT` renvoie tous les morceaux associés à cet `Artist` spécifique.
Pour des exemples de code utilisant `Select` et `ExecuteStatement`, consultez [Instructions PartiQL de sélection pour DynamoDB](ql-reference.select.md).
------
# Différences dans l’analyse d’une table
Dans SQL, une instruction `SELECT` sans une clause `WHERE` retourne chaque ligne d’une table. Dans Amazon DynamoDB, l’opération `Scan` effectue la même chose. Dans les deux cas, vous pouvez extraire tous les éléments, ou seulement certains d’entre eux.
Que vous utilisiez une base de données SQL ou NoSQL, les analyses doivent être utilisées avec modération, car elles peuvent consommer d’importantes quantités de ressources système. Parfois, une analyse est appropriée (analyse d’une petite table, par exemple) ou inévitable (exportation en bloc de données, par exemple). Cependant, en règle générale, vous devez concevoir vos applications de façon à éviter d’exécuter des analyses. Pour de plus amples informations, veuillez consulter [Interrogation de tables dans DynamoDB](Query.md).
**Note**
L’exportation en masse crée également au moins un fichier par partition. Tous les éléments de chaque fichier proviennent de l’espace de clés haché de cette partition particulière.
**Topics**
+ [Analyse d’une table avec SQL](#SQLtoNoSQL.ReadData.Scan.SQL)
+ [Analyse d’une table dans DynamoDB](#SQLtoNoSQL.ReadData.Scan.DynamoDB)
## Analyse d’une table avec SQL
Lorsque vous utilisez SQL, vous pouvez analyser une table et en extraire toutes les données en utilisant une instruction `SELECT` sans spécifier de clause `WHERE`. Vous pouvez demander une ou plusieurs colonnes dans le résultat. Ou, vous pouvez demander leur totalité si vous utilisez le caractère générique (\$1).
Voici des exemples d’utilisation d’une déclaration `SELECT`.
```
/* Return all of the data in the table */
SELECT * FROM Music;
```
```
/* Return all of the values for Artist and Title */
SELECT Artist, Title FROM Music;
```
## Analyse d’une table dans DynamoDB
Dans Amazon DynamoDB, vous pouvez analyser une table à l’aide de l’API DynamoDB ou de [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (langage de requête compatible SQL).
------
#### [ DynamoDB API ]
Grâce à l’API DynamoDB, vous utilisez l’opération `Scan` pour renvoyer un ou plusieurs éléments et attributs d’élément en accédant à chaque élément dans une table ou un index secondaire.
```
// Return all of the data in the table
{
TableName: "Music"
}
```
```
// Return all of the values for Artist and Title
{
TableName: "Music",
ProjectionExpression: "Artist, Title"
}
```
L’opération `Scan` propose également un paramètre `FilterExpression` qui permet d’écarter les éléments qui ne doivent pas figurer dans les résultats. Une `FilterExpression` est appliquée une fois l’analyse terminée, avant que les résultats vous soient renvoyés. Cela n’est pas recommandé avec des tables volumineuses, car vous continuez d’être facturé pour l’opération `Scan` complète, même si seuls quelques éléments correspondants sont renvoyés.
------
#### [ PartiQL for DynamoDB ]
Avec PartiQL, vous procédez à une analyse à l’aide de l’opération `ExecuteStatement`, qui permet de renvoyer l’ensemble du contenu d’une table utilisant l’instruction `Select`.
```
SELECT AlbumTitle, Year, Price
FROM Music
```
Notez que cette instruction renvoie tous les éléments de la table Music.
Pour des exemples de code utilisant `Select` et `ExecuteStatement`, consultez [Instructions PartiQL de sélection pour DynamoDB](ql-reference.select.md).
------
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la gestion d’index
Les index donnent accès à d’autres modèles de requête et peuvent accélérer les requêtes. Cette section compare la création et l’utilisation des index dans SQL et Amazon DynamoDB.
Que vous utilisiez une base de données relationnelle ou DynamoDB, vous devez recourir à la création d’index judicieusement. Chaque fois qu’une écriture se produit sur une table, tous les index de la table doivent être mis à jour. Dans un environnement à forte densité d’écritures avec de grandes tables, cette opération peut consommer d’importantes quantité de ressources système. Dans un environnement en lecture seule ou principalement en lecture, ce risque est moins important. Cependant, vous devez vous assurer que les index sont effectivement utilisés par votre application et pas simplement qu’ils occupent de l’espace.
**Topics**
+ [Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la création d’un index](#SQLtoNoSQL.Indexes.Creating)
+ [Différences entre une base de données relationnelle (SQL) et DynamoDB lors de l’interrogation et de l’analyse d’un index](#SQLtoNoSQL.Indexes.QueryAndScan)
## Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la création d’un index
Comparez l’instruction `CREATE INDEX` dans SQL avec l’opération `UpdateTable` dans Amazon DynamoDB.
**Topics**
+ [Création d’un index avec SQL](#SQLtoNoSQL.Indexes.Creating.SQL)
+ [Création d’un index dans DynamoDB](#SQLtoNoSQL.Indexes.Creating.DynamoDB)
### Création d’un index avec SQL
Dans une base de données relationnelle, un index est une structure de données qui vous permet d’exécuter des requêtes rapides sur différentes colonnes d’une table. Vous pouvez utiliser l’instruction SQL `CREATE INDEX` pour ajouter un index à une table existante, en spécifiant les colonnes à indexer. Une fois que l’index a été créé, vous pouvez interroger les données de la table comme à l’habitude, mais maintenant la base de données peut utiliser l’index pour retrouver rapidement les lignes spécifiées dans le tableau au lieu d’analyser la totalité de la table.
Une fois que vous créez un index, la base de données le gère automatiquement. Chaque fois que vous modifiez les données de la table, l’index est automatiquement modifié pour refléter les modifications de la table.
Dans MySQL, il vous faudrait créer un index semblable au suivant.
```
CREATE INDEX GenreAndPriceIndex
ON Music (genre, price);
```
### Création d’un index dans DynamoDB
Dans DynamoDB, vous pouvez créer et utiliser un *index secondaire* à des fins similaires.
Les index dans DynamoDB sont différents de leurs équivalents relationnels. Lorsque vous créez un index secondaire, vous devez spécifier ses attributs de clé, c’est-à-dire une clé de partition et une clé de tri. Après avoir créé l’index secondaire, vous pouvez effectuer une opération `Query` ou `Scan` sur celui-ci, comme vous le feriez avec une table. DynamoDB n’ayant pas d’optimiseur de requête, un index secondaire n’est utilisé que lorsque vous effectuez une opération `Query` ou `Scan` sur celui-ci.
DynamoDB prend en charge deux types d’index :
+ Index secondaires globaux – La clé primaire de l’index peut être constituée de deux attributs quelconques de sa table.
+ Index secondaires locaux – La clé de partition de l’index doit être la même que la clé de partition de sa table. Cependant, la clé de tri peut être n’importe quel autre attribut.
DynamoDB veille à ce que les données dans un index secondaire soient éventuellement cohérentes avec sa table. Vous pouvez demander des opérations `Query` ou `Scan` fortement cohérentes sur une table ou un index secondaire local. Cependant, les index secondaires globaux ne prennent en charge que la cohérence éventuelle.
Vous pouvez ajouter un index secondaire global à une table existante à l’aide de l’opération `UpdateTable` et en spécifiant `GlobalSecondaryIndexUpdates`.
```
{
TableName: "Music",
AttributeDefinitions:[
{AttributeName: "Genre", AttributeType: "S"},
{AttributeName: "Price", AttributeType: "N"}
],
GlobalSecondaryIndexUpdates: [
{
Create: {
IndexName: "GenreAndPriceIndex",
KeySchema: [
{AttributeName: "Genre", KeyType: "HASH"}, //Partition key
{AttributeName: "Price", KeyType: "RANGE"}, //Sort key
],
Projection: {
"ProjectionType": "ALL"
},
ProvisionedThroughput: { // Only specified if using provisioned mode
"ReadCapacityUnits": 1,"WriteCapacityUnits": 1
}
}
}
]
}
```
Vous devez fournir les paramètres suivants à `UpdateTable` :
+ `TableName` – Table à laquelle l’index sera associé.
+ `AttributeDefinitions` – Types de données pour les attributs de schéma de clé de l’index.
+ `GlobalSecondaryIndexUpdates` – Détails sur l’index que vous souhaitez créer :
+ `IndexName` – Nom pour l’index.
+ `KeySchema` – Attributs utilisés pour la clé primaire de l’index.
+ `Projection` – Attributs de la table qui sont copiés dans l’index. Dans ce cas, `ALL` signifie que tous les attributs sont copiés.
+ `ProvisionedThroughput (for provisioned tables)` – Nombre de lectures et d’écritures par seconde nécessaires pour ce index. (Cette information est distincte des paramètres de débit alloué de la table.)
Une partie de cette opération implique le renvoi de données de la table vers le nouvel index. Pendant le renvoi, la table demeure disponible. Cependant, l’index n’est pas prêt jusqu’à ce que son attribut `Backfilling` passe de true à false. Vous pouvez utiliser l’opération `DescribeTable` pour afficher cet attribut.
## Différences entre une base de données relationnelle (SQL) et DynamoDB lors de l’interrogation et de l’analyse d’un index
Comparez l’interrogation et l’analyse d’un index à l’aide de l’instruction SELECT dans SQL avec les opérations `Query` et `Scan` dans Amazon DynamoDB.
**Topics**
+ [Interrogation et analyse d’un index avec SQL](#SQLtoNoSQL.Indexes.QueryAndScan.SQL)
+ [Interrogation et analyse d’un index dans DynamoDB](#SQLtoNoSQL.Indexes.QueryAndScan.DynamoDB)
### Interrogation et analyse d’un index avec SQL
Dans une base de données relationnelle, vous n’utilisez pas directement les index. Au lieu de cela, vous interrogez les tables à l’aide d’instructions `SELECT` et l’optimiseur de requête peut utiliser tous les index.
Un *optimiseur de requête* est un composant d’un système de gestion de base de données relationnelle (SGBDR) qui évalue les index disponibles et détermine s’ils peuvent être utilisés pour accélérer une requête. Si tel est le cas, le SGBDR accède d’abord à l’index, puis l’utilise pour rechercher les données dans la table.
Voici quelques instructions SQL qui peuvent être utilisées *GenreAndPriceIndex*pour améliorer les performances. Nous supposons que la table *Music* possède suffisamment de données pour que l’optimiseur de requête décide d’utiliser cet index, plutôt que de simplement analyser la totalité de la table.
```
/* All of the rock songs */
SELECT * FROM Music
WHERE Genre = 'Rock';
```
```
/* All of the cheap country songs */
SELECT Artist, SongTitle, Price FROM Music
WHERE Genre = 'Country' AND Price < 0.50;
```
### Interrogation et analyse d’un index dans DynamoDB
Dans DynamoDB, vous effectuez les opérations `Query` et `Scan` directement sur l’index, de la même manière que vous le feriez sur une table. Vous pouvez interroger ou analyser l’index à l’aide de l’API DynamoDB ou de [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (langage de requête compatible SQL). Vous devez spécifier à la fois `TableName` et `IndexName`.
Voici quelques requêtes effectuées *GenreAndPriceIndex*dans DynamoDB. (Le schéma de clé de l’index est composé de *Genre* et de *Price*.)
------
#### [ DynamoDB API ]
```
// All of the rock songs
{
TableName: "Music",
IndexName: "GenreAndPriceIndex",
KeyConditionExpression: "Genre = :genre",
ExpressionAttributeValues: {
":genre": "Rock"
},
};
```
Cet exemple utilise une `ProjectionExpression` pour indiquer que vous souhaitez que certains attributs seulement, et non leur totalité, apparaissent dans les résultats.
```
// All of the cheap country songs
{
TableName: "Music",
IndexName: "GenreAndPriceIndex",
KeyConditionExpression: "Genre = :genre and Price < :price",
ExpressionAttributeValues: {
":genre": "Country",
":price": 0.50
},
ProjectionExpression: "Artist, SongTitle, Price"
};
```
Ce qui suit est un scan en cours *GenreAndPriceIndex*.
```
// Return all of the data in the index
{
TableName: "Music",
IndexName: "GenreAndPriceIndex"
}
```
------
#### [ PartiQL for DynamoDB ]
Avec PartiQL, vous utilisez l’instruction PartiQL `Select` pour interroger et analyser l’index.
```
// All of the rock songs
SELECT *
FROM Music.GenreAndPriceIndex
WHERE Genre = 'Rock'
```
```
// All of the cheap country songs
SELECT *
FROM Music.GenreAndPriceIndex
WHERE Genre = 'Rock' AND Price < 0.50
```
Ce qui suit est un scan en cours *GenreAndPriceIndex*.
```
// Return all of the data in the index
SELECT *
FROM Music.GenreAndPriceIndex
```
**Note**
Pour obtenir des exemples de code utilisant `Select`, consultez [Instructions PartiQL de sélection pour DynamoDB](ql-reference.select.md).
------
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la modification de données dans une table
Le langage SQL fournit l’instruction `UPDATE` pour modifier les données. Amazon DynamoDB utilise l’opération `UpdateItem` pour accomplir des tâches similaires.
**Topics**
+ [Modification de données dans une table avec SQL](#SQLtoNoSQL.UpdateData.SQL)
+ [Modification de données dans une table dans DynamoDB](#SQLtoNoSQL.UpdateData.DynamoDB)
## Modification de données dans une table avec SQL
En SQL, la modification d’une ou plusieurs lignes s’effectue via l’instruction `UPDATE`. La clause `SET` spécifie de nouvelles valeurs pour une ou plusieurs colonnes, et la clause `WHERE` détermine les lignes qui sont modifiées. Voici un exemple.
```
UPDATE Music
SET RecordLabel = 'Global Records'
WHERE Artist = 'No One You Know' AND SongTitle = 'Call Me Today';
```
Si aucune ligne ne correspond à la clause `WHERE`, l’instruction `UPDATE` n’a aucun effet.
## Modification de données dans une table dans DynamoDB
Dans DynamoDB, vous pouvez modifier un élément unique à l’aide de l’API DynamoDB ou de [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (langage de requête compatible SQL). Si vous voulez modifier plusieurs éléments, vous devez utiliser plusieurs opérations.
------
#### [ DynamoDB API ]
Avec l’API DynamoDB, vous devez utiliser l’opération `UpdateItem` pour modifier un élément unique.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET RecordLabel = :label",
ExpressionAttributeValues: {
":label": "Global Records"
}
}
```
Vous devez spécifier les attributs `Key` de l’élément à modifier ainsi qu’une `UpdateExpression` pour spécifier les valeurs des attributs. `UpdateItem` se comporte comme une opération « upsert » (mise à jour/insertion). L’élément est mis à jour s’il existe dans la table, mais dans le cas contraire, un nouvel élément est ajouté (inséré).
`UpdateItem` prend en charge les *écritures conditionnelles*, où l’opération aboutit uniquement si un attribut `ConditionExpression` a la valeur true. Par exemple, l’opération `UpdateItem` suivante n’effectue pas la mise à jour, sauf si le prix de la chanson est supérieur ou égal à 2,00.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET RecordLabel = :label",
ConditionExpression: "Price >= :p",
ExpressionAttributeValues: {
":label": "Global Records",
":p": 2.00
}
}
```
`UpdateItem` prend également en charge les *compteurs atomiques*, ou les attributs de type `Number` qui peuvent être incrémentés ou décrémentés. Les compteurs atomiques sont similaires en de nombreuses façons aux générateurs de séquence, aux colonnes d’identité ou aux champs d’incrémentation automatique dans les bases de données SQL.
Voici un exemple d’opération `UpdateItem` pour initialiser un nouvel attribut (*Plays*) et suivre le nombre de fois qu’une chanson a été écoutée.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET Plays = :val",
ExpressionAttributeValues: {
":val": 0
},
ReturnValues: "UPDATED_NEW"
}
```
Le paramètre `ReturnValues` est défini sur `UPDATED_NEW`, qui retourne les nouvelles valeurs de tous les attributs qui ont été mis à jour. Dans ce cas, la valeur 0 (zéro) est retournée.
Chaque fois que quelqu’un écoute cette chanson, nous pouvons utiliser l’opération `UpdateItem` suivante pour incrémenter la valeur *Plays* d’une unité.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET Plays = Plays + :incr",
ExpressionAttributeValues: {
":incr": 1
},
ReturnValues: "UPDATED_NEW"
}
```
------
#### [ PartiQL for DynamoDB ]
Avec PartiQL, vous utilisez l’opération `ExecuteStatement` pour modifier un élément d’une table, à l’aide de l’instruction PartiQL `Update`.
La clé primaire de cette table comprend *Artist* et *SongTitle*. Vous devez spécifier les valeurs de ces attributs.
```
UPDATE Music
SET RecordLabel ='Global Records'
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
Vous pouvez également modifier plusieurs champs à la fois, tel qu’illustré dans l’exemple suivant.
```
UPDATE Music
SET RecordLabel = 'Global Records'
SET AwardsWon = 10
WHERE Artist ='No One You Know' AND SongTitle='Call Me Today'
```
`Update` prend également en charge les *compteurs atomiques*, ou les attributs de type `Number` qui peuvent être incrémentés ou décrémentés. Les compteurs atomiques sont similaires en de nombreuses façons aux générateurs de séquence, aux colonnes d’identité ou aux champs d’incrémentation automatique dans les bases de données SQL.
Voici un exemple d’instruction `Update` destinée à initialiser un nouvel attribut (*Plays* (Lectures)) et à suivre le nombre de fois où un morceau a été joué.
```
UPDATE Music
SET Plays = 0
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
Chaque fois que quelqu’un écoute ce morceau, nous pouvons utiliser l’instruction `Update` suivante pour incrémenter la valeur *Plays* (Lectures) d’une unité.
```
UPDATE Music
SET Plays = Plays + 1
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
**Note**
Pour des exemples de code utilisant `Update` et `ExecuteStatement`, consultez [Instructions de mise à jour de PartiQL pour DynamoDB](ql-reference.update.md).
------
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la suppression de données dans une table
Dans SQL, l’instruction `DELETE` supprime une ou plusieurs lignes d’une table. Amazon DynamoDB utilise l’opération `DeleteItem` pour supprimer un élément à la fois.
**Topics**
+ [Suppression de données d’une table avec SQL](#SQLtoNoSQL.DeleteData.SQL)
+ [Suppression de données d’une table dans DynamoDB](#SQLtoNoSQL.DeleteData.DynamoDB)
## Suppression de données d’une table avec SQL
Dans SQL, vous utilisez l’instruction `DELETE` pour supprimer une ou plusieurs lignes. La clause `WHERE` détermine les lignes que vous voulez modifier. Voici un exemple.
```
DELETE FROM Music
WHERE Artist = 'The Acme Band' AND SongTitle = 'Look Out, World';
```
Vous pouvez modifier la clause `WHERE` pour supprimer plusieurs lignes. Par exemple, vous pouvez supprimer tous les morceaux d’un artiste particulier, comme illustré dans l’exemple ci-après :
```
DELETE FROM Music WHERE Artist = 'The Acme Band'
```
## Suppression de données d’une table dans DynamoDB
Dans DynamoDB, vous pouvez supprimer un élément unique à l’aide de l’API DynamoDB ou de [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (langage de requête compatible SQL). Si vous voulez modifier plusieurs éléments, vous devez utiliser plusieurs opérations.
------
#### [ DynamoDB API ]
Avec l’API DynamoDB, vous devez utiliser l’opération `DeleteItem` pour supprimer les données d’une table, un élément à la fois. Vous devez spécifier les valeurs de clé primaire de l’élément.
```
{
TableName: "Music",
Key: {
Artist: "The Acme Band",
SongTitle: "Look Out, World"
}
}
```
**Note**
Outre `DeleteItem`, Amazon DynamoDB prend en charge une opération `BatchWriteItem` pour supprimer plusieurs éléments à la fois.
`DeleteItem` prend en charge les *écritures conditionnelles*, où l’opération aboutit uniquement si un attribut `ConditionExpression` a la valeur true. Par exemple, l'`DeleteItem`opération suivante supprime l'élément uniquement s'il possède un *RecordLabel*attribut.
```
{
TableName: "Music",
Key: {
Artist: "The Acme Band",
SongTitle: "Look Out, World"
},
ConditionExpression: "attribute_exists(RecordLabel)"
}
```
------
#### [ PartiQL for DynamoDB ]
Avec PartiQL, vous utilisez l’instruction `Delete` via l’opération `ExecuteStatement` afin de supprimer des données d’une table, un élément à la fois. Vous devez spécifier les valeurs de clé primaire de l’élément.
La clé primaire de cette table comprend *Artist* et *SongTitle*. Vous devez spécifier les valeurs de ces attributs.
```
DELETE FROM Music
WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks'
```
Vous pouvez également spécifier des conditions supplémentaires pour l’opération. L’opération `DELETE` suivante ne supprime l’élément que s’il a plus de 11 *Awards* (Récompenses).
```
DELETE FROM Music
WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks' AND Awards > 11
```
**Note**
Pour des exemples de code utilisant `DELETE` et `ExecuteStatement`, consultez [Instructions de suppression de PartiQL pour DynamoDB](ql-reference.delete.md).
------
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la suppression d’une table
Dans SQL, vous utilisez l’instruction `DROP TABLE` pour supprimer une table. Dans Amazon DynamoDB, vous utilisez l’opération `DeleteTable`.
**Topics**
+ [Suppression d’une table avec SQL](#SQLtoNoSQL.RemoveTable.SQL)
+ [Suppression d’une table dans DynamoDB](#SQLtoNoSQL.RemoveTable.DynamoDB)
## Suppression d’une table avec SQL
Lorsque vous n’avez plus besoin d’une table et que vous voulez la supprimer définitivement, vous devez utiliser l’instruction `DROP TABLE` en SQL.
```
DROP TABLE Music;
```
Une fois qu’une table est supprimée, elle ne peut pas être récupérée. (Certaines bases de données relationnelles vous permettent réellement d’annuler une opération `DROP TABLE`, mais il s’agit d’une fonctionnalité propre au fournisseur et qui n’est pas largement appliquée.)
## Suppression d’une table dans DynamoDB
Dans DynamoDB, `DeleteTable` est une opération similaire. Dans l’exemple suivant, la table est supprimée de façon définitive.
```
{
TableName: "Music"
}
```
# Ressources et outils de formation Amazon DynamoDB
Vous pouvez utiliser les ressources supplémentaires suivantes pour comprendre et utiliser DynamoDB.
**Topics**
+ [Outils de codage et de visualisation](#AdditionalResources.Tools)
+ [Articles de conseils prescriptifs](#AdditionalResources.PrescriptiveGuidance)
+ [Articles du Centre de connaissances](#AdditionalResources.KnowledgeCenter)
+ [Articles de blog, référentiels et guides](#AdditionalResources.Guides)
+ [Présentations de la modélisation des données et des modèles de conception](#AdditionalResources.DataModeling)
+ [Formation](#AdditionalResources.Training)
## Outils de codage et de visualisation
Vous pouvez utiliser les outils de codage et de visualisation suivants avec DynamoDB :
+ [NoSQL Workbench pour Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.html) : outil visuel unifié qui vous aide à concevoir, créer, interroger et gérer des tables DynamoDB. Il fournit des fonctionnalités de modélisation des données, de visualisation des données et de développement de requêtes.
+ [Dynobase](https://dynobase.dev/) : outil de bureau qui facilite la visualisation et l’utilisation de vos tables DynamoDB, la création de code d’application et la modification de registres avec une validation en temps réel.
+ [DynamoDB](https://github.com/jeremydaly/dynamodb-toolbox) Toolbox — Un projet de Jeremy Daly qui fournit des utilitaires utiles pour travailler avec la modélisation des données et Node.js. JavaScript
+ [DynamoDB Streams Processor](https://github.com/jeremydaly/dynamodb-streams-processor) : outil simple facilitant l’utilisation de [DynamoDB streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html).
## Articles de conseils prescriptifs
AWS Prescriptive Guidance fournit des stratégies, des guides et des modèles éprouvés pour vous aider à accélérer vos projets. Ces ressources ont été développées par des experts en AWS technologie et la communauté mondiale de AWS partenaires, sur la base de leurs années d'expérience à aider les clients à atteindre leurs objectifs commerciaux.
**Modélisation et migration des données**
+ [Modèle de données hiérarchiques dans DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-hierarchical-data-model/introduction.html)
+ [Modélisation de données avec DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-data-modeling/welcome.html)
+ [Migrer une base de données Oracle vers DynamoDB à l'aide de AWS DMS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.html)
**Tableaux globaux**
+ [Utilisation des tables globales Amazon DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-global-tables/introduction.html)
**Serverless (Sans serveur)**
+ [Implémentez le modèle de saga sans serveur avec AWS Step Functions](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/implement-the-serverless-saga-pattern-by-using-aws-step-functions.html)
**Architecture SaaS**
+ [Gestion des locataires sur plusieurs produits SaaS sur un seul plan de contrôle](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/manage-tenants-across-multiple-saas-products-on-a-single-control-plane.html)
+ [Intégration des locataires dans l’architecture SaaS pour le modèle de silo avec C\$1 et AWS CDK](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html)
**Protection et transfert des données**
+ [Configuration de l’accès intercompte à Amazon DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)
+ [Options de copie complète des tables pour DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-full-table-copy-options/)
+ [Stratégie de reprise après sinistre pour les bases de données sur AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/strategy-database-disaster-recovery/)
**Miscellaneous**
+ [Aide pour appliquer le balisage dans DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/help-enforce-dynamodb-tagging.html)
**Démonstrations vidéo de conseils prescriptifs**
+ [Utilisation d’une architecture sans serveur pour créer des pipelines de données](https://youtu.be/JiWHomdh1oI?)
+ [Novartis – Buying Engine : portail d’approvisionnement basé sur l’IA](https://youtu.be/vp8oPiHN4cA)
+ [Veritiv : utilisez Insights pour prévoir la demande de vente sur AWS les lacs de données](https://youtu.be/jg85DzUZ9Ac)
+ [mimik : le cloud Edge hybride s'appuie sur le support du AWS maillage des microservices Edge](https://youtu.be/-S-R7MWRpaI)
+ [Récupération de données de modification avec Amazon DynamoDB](https://youtu.be/6YVjzD-70p4)
Pour d’autres articles et vidéos sur les conseils prescriptifs pour DynamoDB, consultez [Conseils prescriptifs](https://tiny.amazon.com/fiui3cog/ForinternaldemoofnewpageExternalURLwillbeneededforlive).
## Articles du Centre de connaissances
Les articles et vidéos du AWS Knowledge Center couvrent les questions et demandes les plus fréquentes que nous recevons de la part des AWS clients. Vous trouverez ci-dessous quelques articles récents du Centre de connaissances sur des tâches spécifiques liées à DynamoDB :
**Optimisation des coûts**
+ [Comment optimiser les coûts avec Amazon DynamoDB ?](https://repost.aws/knowledge-center/dynamodb-optimize-costs)
**Limitation et latence**
+ [Comment puis-je résoudre les problèmes de latence élevée sur une table Amazon DynamoDB ?](https://repost.aws/knowledge-center/dynamodb-high-latency)
+ [Pourquoi ma table DynamoDB est-elle limitée ?](https://repost.aws/knowledge-center/dynamodb-table-throttled)
+ [Pourquoi ma table DynamoDB à la demande est-elle limitée ?](https://repost.aws/knowledge-center/on-demand-table-throttling-dynamodb)
**Pagination**
+ [Comment implémenter la pagination dans DynamoDB ?](https://repost.aws/knowledge-center/dynamodb-implement-pagination)
**Transactions**
+ [Pourquoi mon appel d’API `TransactWriteItems` échoue-t-il dans DynamoDB ?](https://repost.aws/knowledge-center/dynamodb-transactwriteitems)
**Résolution des problèmes**
[]()
+ [Comment résoudre les problèmes liés à l’autoscaling de DynamoDB ?](https://repost.aws/knowledge-center/dynamodb-auto-scaling)
+ [Comment résoudre les erreurs HTTP 4XX dans DynamoDB ?](https://repost.aws/knowledge-center/usererrors-dynamodb-table)
Pour des articles et des vidéos supplémentaires sur DynamoDB, consultez les [articles du Centre de connaissances](https://repost.aws/search/knowledge-center?globalSearch=dynamodb).
## Articles de blog, référentiels et guides
Outre le [Guide du développeur DynamoDB](Introduction.md), il existe de nombreuses ressources utiles pour utiliser DynamoDB. Voici une sélection d’articles de blog, de référentiels et de guides relatifs à l’utilisation de DynamoDB :
+ AWS [référentiel d'exemples de [code DynamoDB](https://github.com/aws-samples/aws-dynamodb-examples) dans AWS différents langages du SDK [:](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/node.js) Node.js, [Java](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/java), [Python](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/python), .Net [[,](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/golang) Go et Rust](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/dotnet).](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/rust)
+ [Le livre DynamoDB](https://www.dynamodbbook.com/) : guide complet d' DeBrieAlex qui enseigne une approche stratégique [de](https://twitter.com/alexbdebrie) la modélisation des données avec DynamoDB.
+ Guide [DynamoDB](https://www.dynamodbguide.com/) : guide ouvert d' DeBrieAlex qui décrit les concepts [de](https://twitter.com/alexbdebrie) base et les fonctionnalités avancées de la base de données DynamoDB NoSQL.
+ [Comment passer de RDBMS à DynamoDB en 20 étapes faciles](https://www.jeremydaly.com/how-to-switch-from-rdbms-to-dynamodb-in-20-easy-steps/) : liste d’étapes utiles pour l’apprentissage de la modélisation de données par [Jeremy Daly](https://twitter.com/jeremy_daly).
+ [Aide-mémoire JavaScript DocumentClient DynamoDB : aide-mémoire destiné à](https://github.com/dabit3/dynamodb-documentclient-cheat-sheet) vous aider à commencer à créer des applications avec DynamoDB dans un fichier Node.js ou un environnement. JavaScript
+ [Vidéos sur le concept de base de DynamoDB](https://www.youtube.com/playlist?list=PLJo-rJlep0EDNtcDeHDMqsXJcuKMcrC5F) : cette playlist couvre de nombreux concepts de base de DynamoDB.
## Présentations de la modélisation des données et des modèles de conception
Vous pouvez utiliser les ressources suivantes sur la modélisation des données et les modèles de conception pour tirer le meilleur parti de DynamoDB :
+ [AWS re:Invent 2019 : Modélisation des données avec DynamoDB](https://www.youtube.com/watch?v=DIQVJqiSUkE)
+ Une conférence d'[Alex DeBrie](https://twitter.com/alexbdebrie) qui vous aide à vous familiariser avec les principes de la modélisation des données DynamoDB.
+ [AWS re:Invent 2020 : Modélisation des données avec DynamoDB — Partie 1](https://www.youtube.com/watch?v=fiP2e-g-r4g)
+ [AWS re:Invent 2020 : Modélisation des données avec DynamoDB — Partie 2](https://www.youtube.com/watch?v=0uLF1tjI_BI)
+ [AWS re:Invent 2017 : Modèles de design avancés](https://www.youtube.com/watch?v=jzeKPKpucS0)
+ [AWS re:Invent 2018 : modèles de design avancés](https://www.youtube.com/watch?v=HaEPXoXVf2k)
+ [AWS re:Invent 2019 : modèles de conception avancés](https://www.youtube.com/watch?v=6yqfmXiZTlM)
+ Jeremy Daly partage ses [12 points clés à retenir](https://www.jeremydaly.com/takeaways-from-dynamodb-deep-dive-advanced-design-patterns-dat403/) au cours de cette session.
+ [AWS re:Invent 2020 : modèles de conception avancée DynamoDB – Partie 1](https://www.youtube.com/watch?v=MF9a1UNOAQo&index=1)
+ [AWS re:Invent 2020 : Modèles de conception avancés de DynamoDB — Partie 2](https://www.youtube.com/watch?v=_KNrRdWD25M&index=2)
+ [Heures de bureau DynamoDB sur Twitch](https://amazondynamodbofficehrs.splashthat.com/)
**Note**
Chaque session couvre différents exemples et cas d’utilisation.
## Formation
Il existe de nombreux cours de formation et options pédagogiques pour en savoir plus sur DynamoDB. Voici quelques exemples actuels :
+ [Développement avec Amazon DynamoDB](https://www.aws.training/Details/Curriculum?id=65583) : conçu AWS par pour vous permettre de passer du statut de débutant à celui d'expert dans le développement d'applications réelles avec la modélisation des données pour Amazon DynamoDB.
+ [Cours d’approfondissement DynamoDB](https://www.pluralsight.com/courses/aws-dynamodb-deep-dive-2019) : cours créé par Pluralsight.
+ [Amazon DynamoDB : création d'applications NoSQL pilotées par des bases](https://www.edx.org/course/amazon-dynamodb-building-nosql-database-driven-app) de données — Un cours organisé par l'équipe de formation et de certification sur edX. AWS