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.
# Commencer à utiliser Amazon Keyspaces (pour Apache Cassandra)
Si vous débutez avec Apache Cassandra et Amazon Keyspaces, ce didacticiel vous explique comment installer les programmes et outils nécessaires pour utiliser Amazon Keyspaces avec succès. Vous allez apprendre à créer un espace de touches et une table à l'aide du langage de requête Cassandra (CQL) AWS Management Console, du ou du AWS Command Line Interface ().AWS CLI Vous utilisez ensuite Cassandra Query Language (CQL) pour effectuer des opérations de création, de lecture, de mise à jour et de suppression (CRUD) sur les données de votre table Amazon Keyspaces.
Ce didacticiel couvre les étapes suivantes.
+ **Conditions préalables** — Avant de commencer le didacticiel, suivez les instructions de AWS configuration pour vous inscrire AWS et créer un utilisateur IAM ayant accès à Amazon Keyspaces. Ensuite, vous configurez le `cqhsh-expansion` et AWS CloudShell. Vous pouvez également utiliser le AWS CLI pour créer des ressources dans Amazon Keyspaces.
+ **Étape 1 : Création d'un espace de touches et d'un tableau** — Dans cette section, vous allez créer un espace de touches nommé « catalogue » et une table nommée « book\$1awards » à l'intérieur de celui-ci. Vous allez spécifier les colonnes, les types de données, la clé de partition et la colonne de clustering de la table en utilisant le AWS Management Console, CQL ou le. AWS CLI
+ **Étape 2 : Effectuer des opérations CRUD** — Ici, vous allez utiliser le `cqlsh-expansion` in CloudShell pour insérer, lire, mettre à jour et supprimer des données dans la table « book\$1awards ». Vous apprendrez à utiliser diverses instructions CQL telles que SELECT, INSERT, UPDATE et DELETE, et à vous entraîner à filtrer et à modifier des données.
+ **Étape 3 : Nettoyer les ressources** — Pour éviter d'encourir des frais pour les ressources non utilisées, cette section vous explique comment supprimer la table « book\$1awards » et l'espace de touche « catalogue » à l'aide de la console, du CQL ou du. AWS CLI
Pour des didacticiels sur la connexion par programmation à Amazon Keyspaces à l'aide de différents pilotes clients Apache Cassandra, consultez. [Utilisation d'un pilote client Cassandra pour accéder à Amazon Keyspaces par programmation](programmatic.drivers.md) Pour des exemples de code utilisant différents AWS SDKs, consultez [Exemples de code pour Amazon Keyspaces](https://docs.aws.amazon.com/keyspaces/latest/devguide/service_code_examples.html) utilisant. AWS SDKs
**Topics**
+ [
# Conditions préalables et considérations relatives au didacticiel
](getting-started.before-you-begin.md)
+ [
# Création d'un keyspace dans Amazon Keyspaces
](getting-started.keyspaces.md)
+ [
# Vérifiez le statut de création des espaces de touches dans Amazon Keyspaces
](keyspaces-create.md)
+ [
# Création d'un tableau dans Amazon Keyspaces
](getting-started.tables.md)
+ [
# Vérifiez l'état de création des tables dans Amazon Keyspaces
](tables-create.md)
+ [
# Création, lecture, mise à jour et suppression de données (CRUD) à l'aide de CQL dans Amazon Keyspaces
](getting-started.dml.md)
+ [
# Supprimer un tableau dans Amazon Keyspaces
](getting-started.clean-up.table.md)
+ [
# Supprimer un espace de touches dans Amazon Keyspaces
](getting-started.clean-up.keyspace.md)
# Conditions préalables et considérations relatives au didacticiel
Avant de commencer à utiliser Amazon Keyspaces, suivez les instructions de AWS configuration indiquées dans. [Accès à Amazon Keyspaces (pour Apache Cassandra)](accessing.md) Ces étapes incluent l'inscription AWS et la création d'un utilisateur Gestion des identités et des accès AWS (IAM) ayant accès à Amazon Keyspaces.
Pour terminer toutes les étapes du didacticiel, vous devez procéder à l'installation`cqlsh`. Vous pouvez suivre les instructions de configuration à l'adresse[Utilisation `cqlsh` pour se connecter à Amazon Keyspaces](programmatic.cqlsh.md).
Pour accéder à Amazon Keyspaces en utilisant `cqlsh` ou le AWS CLI, nous vous recommandons d'utiliser. AWS CloudShell CloudShellest un shell pré-authentifié basé sur un navigateur que vous pouvez lancer directement depuis le. AWS Management Console Vous pouvez exécuter des commandes AWS Command Line Interface (AWS CLI) sur Amazon Keyspaces à l'aide de votre shell préféré (Bash PowerShell ou Z shell). Pour l'utiliser`cqlsh`, vous devez installer le`cqlsh-expansion`. Pour les instructions d'`cqlsh-expansion`installation, voir[Utilisation du `cqlsh-expansion` pour se connecter à Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh). Pour plus d'informations sur, CloudShell voir[Utilisation AWS CloudShell pour accéder à Amazon Keyspaces](using-aws-with-cloudshell.md).
Pour utiliser le AWS CLI pour créer, afficher et supprimer des ressources dans Amazon Keyspaces, suivez les instructions de configuration sur. [Téléchargement et configuration du AWS CLI](access.cli.md#access.cli.installcli)
Après avoir effectué les étapes préalables, passez à[Création d'un keyspace dans Amazon Keyspaces](getting-started.keyspaces.md).
# Création d'un keyspace dans Amazon Keyspaces
Dans cette section, vous allez créer un espace de touches à l'aide de la console`cqlsh`, ou du AWS CLI.
**Note**
Avant de commencer, assurez-vous d'avoir configuré tous les [prérequis du didacticiel](getting-started.before-you-begin.md).
Un *keyspace* regroupe les tables associées qui sont pertinentes pour une ou plusieurs applications. Un keyspace contient une ou plusieurs tables et définit la stratégie de réplication pour toutes les tables qu'il contient. Pour de plus amples informations sur les keyspaces, veuillez consulter les rubriques suivantes :
+ Instructions du langage de définition des données (DDL) dans la référence du langage CQL : [Keyspaces](cql.ddl.keyspace.md)
+ [Quotas pour Amazon Keyspaces (pour Apache Cassandra)](quotas.md)
Dans ce didacticiel, nous créons un espace de touches à région unique, et la stratégie de réplication de l'espace de touches est la suivante : `SingleRegionStrategy` À l'aide d'Amazon Keyspaces`SingleRegionStrategy`, les données sont répliquées dans trois [zones de disponibilité](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/) en une seule. Région AWS Pour savoir comment créer des espaces clés multirégionaux, consultez. [Création d'un keyspace multirégional dans Amazon Keyspaces](keyspaces-mrr-create.md)
## Utilisation de la console
**Pour créer un keyspace à l'aide de la console**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Dans le panneau de navigation, choisissez **Keyspaces**.
1. Choisissez **Create keyspace**.
1. Dans la zone **Nom du keyspace** entrez **catalog** comme nom de votre keyspace.
**Contraintes de nom :**
+ Le nom ne peut pas être vide.
+ Caractères autorisés : caractères alphanumériques et soulignement ( `_` ).
+ La longueur maximale est de 48 caractères.
1. Sous **Régions AWS**, confirmez que **la réplication par région unique** est la stratégie de réplication pour le keyspace.
1. Pour créer le keyspace, choisissez **Create keyspace (Créer un keyspace)**.
1. Vérifiez que le keyspace `catalog` a été créé en procédant comme suit :
1. Dans le panneau de navigation, choisissez **Keyspaces**.
1. Localisez votre keyspace `catalog` dans la liste des keyspaces.
## Utilisation de CQL
La procédure suivante crée un keyspace à l'aide de CQL.
**Pour créer un keyspace avec CQL**
1. Ouvrez AWS CloudShell et connectez-vous à Amazon Keyspaces à l'aide de la commande suivante. Assurez-vous d'effectuer la mise à jour *us-east-1* avec votre propre région.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
Le résultat de cette commande devrait ressembler à ceci.
```
Connected to Amazon Keyspaces at cassandra.us-east-1.amazonaws.com:9142
[cqlsh 6.1.0 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh current consistency level is ONE.
```
1. Créez votre keyspace à l'aide de la commande CQL suivante.
```
CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
`SingleRegionStrategy`utilise un facteur de réplication de trois et réplique les données dans trois zones de AWS disponibilité de sa région.
**Note**
Amazon Keyspaces met par défaut toutes les entrées en minuscules, sauf si vous les mettez entre guillemets.
1. Vérifiez que votre keyspace a été créé.
```
SELECT * from system_schema.keyspaces;
```
Le résultat de cette commande doit ressembler à ceci.
```
cqlsh> SELECT * from system_schema.keyspaces;
keyspace_name | durable_writes | replication
-------------------------+----------------+-------------------------------------------------------------------------------------
system_schema | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_schema_mcs | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_multiregion_info | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
catalog | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
(5 rows)
```
## En utilisant le AWS CLI
La procédure suivante crée un espace de touches à l'aide du AWS CLI.
**Pour créer un espace de touches à l'aide du AWS CLI**
1. Pour vérifier que votre environnement est configuré, vous pouvez exécuter la commande suivante dans CloudShell.
```
aws keyspaces help
```
1. Créez votre keyspace à l'aide de l' AWS CLI instruction suivante.
```
aws keyspaces create-keyspace --keyspace-name 'catalog'
```
1. Vérifiez que votre keyspace a été créé avec l'instruction suivante AWS CLI
```
aws keyspaces get-keyspace --keyspace-name 'catalog'
```
Le résultat de cette commande doit ressembler à celui de cet exemple.
```
{
"keyspaceName": "catalog",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/",
"replicationStrategy": "SINGLE_REGION"
}
```
# Vérifiez le statut de création des espaces de touches dans Amazon Keyspaces
Amazon Keyspaces exécute des opérations de langage de définition de données (DDL), telles que la création et la suppression d'espaces clés, de manière asynchrone.
Vous pouvez surveiller l'état de création de nouveaux espaces clés dans le AWS Management Console, ce qui indique lorsqu'un espace clé est en attente ou actif. Vous pouvez également contrôler l'état de création d'un nouvel espace de touches par programmation à l'aide de l'espace de touches. `system_schema_mcs` Un espace de touche devient visible dans le `system_schema_mcs` `keyspaces` tableau lorsqu'il est prêt à être utilisé.
Le modèle de conception recommandé pour vérifier qu'un nouvel espace de touches est prêt à être utilisé consiste à interroger la table Amazon `system_schema_mcs` `keyspaces` Keyspaces (system\$1schema\$1mcs.\$1). Pour obtenir la liste des instructions DDL pour les espaces clés, consultez la [Keyspaces](cql.ddl.keyspace.md) section du manuel de référence du langage CQL.
La requête suivante indique si un espace de touches a été créé avec succès.
```
SELECT * FROM system_schema_mcs.keyspaces WHERE keyspace_name = 'mykeyspace';
```
Pour un espace de touches créé avec succès, le résultat de la requête ressemble à ce qui suit.
```
keyspace_name | durable_writes | replication
--------------+-----------------+--------------
mykeyspace | true |{...} 1 item
```
# Création d'un tableau dans Amazon Keyspaces
Dans cette section, vous allez créer une table à l'aide de la console ou du AWS CLI. `cqlsh`
Une table est l'endroit où vos données sont organisées et stockées. La clé primaire de votre table détermine la manière dont les données sont partitionnées dans votre table. La clé primaire est composée d'une clé de partition obligatoire et d'une ou plusieurs colonnes de clustering facultatives. Les valeurs combinées qui composent la clé primaire doivent être uniques pour toutes les données de la table. Pour de plus amples informations sur les balises, veuillez consulter les rubriques suivantes :
+ Conception de la clé de partition : [Comment utiliser efficacement les clés de partition dans Amazon Keyspaces](bp-partition-key-design.md)
+ Utilisation des tables : [Vérifiez l'état de création des tables dans Amazon Keyspaces](tables-create.md)
+ Instructions DDL dans la référence du langage CQL : [Tables](cql.ddl.table.md)
+ Gestion des ressources des tables : [Gestion des ressources sans serveur dans Amazon Keyspaces (pour Apache Cassandra)](serverless_resource_management.md)
+ Surveillance de l'utilisation des ressources des tables : [Surveillance d'Amazon Keyspaces avec Amazon CloudWatch](monitoring-cloudwatch.md)
+ [Quotas pour Amazon Keyspaces (pour Apache Cassandra)](quotas.md)
Lorsque vous créez une table, vous spécifiez les éléments suivants :
+ Nom de la table.
+ Nom et type de données de chaque colonne de la table.
+ Clé primaire de la table.
+ **Clé de partition** — Obligatoire
+ **Colonnes de regroupement — Facultatif**
Utilisez la procédure suivante pour créer une table avec les colonnes, les types de données, les clés de partition et les colonnes de clustering spécifiés.
## Utilisation de la console
La procédure suivante crée la table `book_awards` avec ces colonnes et types de données.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Pour créer une table à l'aide de la console**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Dans le panneau de navigation, choisissez **Keyspaces**.
1. Choisissez `catalog` comme keyspace dans lequel vous souhaitez créer la table.
1. Choisissez **Créer un tableau**.
1. Dans la zone **Nom de la table** entrez **book\$1awards** comme nom pour votre table.
**Contraintes de nom :**
+ Le nom ne peut pas être vide.
+ Caractères autorisés : caractères alphanumériques et soulignement ( `_` ).
+ La longueur maximale est de 48 caractères.
1. Dans la section **Colonnes** répétez les étapes suivantes pour chaque colonne à ajouter à cette table.
Ajoutez les colonnes et types de données suivants.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
1. **Nom** — Entrez le nom de la colonne.
**Contraintes de nom :**
+ Le nom ne peut pas être vide.
+ Caractères autorisés : caractères alphanumériques et soulignement ( `_` ).
+ La longueur maximale est de 48 caractères.
1. **Type** : dans la liste des types de données, choisissez le type de données pour cette colonne.
1. Pour ajouter une autre colonne, choisissez **Ajouter une colonne**.
1. Choisissez `award` et `year` comme clés de partition sous **Partition Key**. Une clé de partition est requise pour chaque table. Une clé de partition peut être constituée d'une ou plusieurs colonnes.
1. Ajoutez `category` et `rank` en tant que **colonnes de clustering**. Les colonnes de clustering sont facultatives et déterminent l'ordre de tri dans chaque partition.
1. Pour ajouter une colonne de clustering, choisissez **Ajouter une colonne de clustering**.
1. Dans la liste des **colonnes**, choisissez une **catégorie**. Dans la liste **Ordre** choisissez **ASC** pour trier par ordre croissant les valeurs de cette colonne. (Choisissez **DESC** pour l'ordre décroissant.)
1. Sélectionnez ensuite **Ajouter une colonne de clustering** et choisissez le **classement.**
1. Dans la section **Paramètres du tableau**, choisissez **Paramètres par défaut**.
1. Choisissez **Créer un tableau**.
1. Vérifiez que votre table a été créée.
1. Dans le volet de navigation, choisissez **Tables**.
1. Confirmez que votre table figure dans la liste des tables.
1. Choisissez le nom de votre table.
1. Vérifiez que toutes vos colonnes et tous vos types de données sont corrects.
**Note**
Les colonnes peuvent ne pas être répertoriées dans le même ordre que celui où vous les avez ajoutées à la table.
## Utilisation de CQL
Cette procédure crée une table avec les colonnes et les types de données suivants à l'aide de CQL. Les `award` colonnes `year` et sont des clés de partition avec `category` et `rank` en tant que colonnes de clustering. Ensemble, elles constituent la clé primaire de la table.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Pour créer une table avec CQL**
1. Ouvrez AWS CloudShell et connectez-vous à Amazon Keyspaces à l'aide de la commande suivante. Assurez-vous d'effectuer la mise à jour *us-east-1* avec votre propre région.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
Le résultat de cette commande devrait ressembler à ceci.
```
Connected to Amazon Keyspaces at cassandra.us-east-1.amazonaws.com:9142
[cqlsh 6.1.0 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh current consistency level is ONE.
```
1. À l'invite d'espace de touche (`cqlsh:keyspace_name>`), créez votre table en entrant le code suivant dans votre fenêtre de commande.
```
CREATE TABLE catalog.book_awards (
year int,
award text,
rank int,
category text,
book_title text,
author text,
publisher text,
PRIMARY KEY ((year, award), category, rank)
);
```
**Note**
`ASC` est l'ordre de mise en cluster par défaut. Vous pouvez également spécifier `DESC` pour l'ordre décroissant.
Notez que les colonnes `year` et `award` sont des colonnes clés de partition. Ensuite, `category` et `rank` les colonnes de clustering sont-elles ordonnées par ordre croissant ()`ASC`. Ensemble, ces colonnes constituent la clé primaire de la table.
1. Vérifiez que votre table a été créée.
```
SELECT * from system_schema.tables WHERE keyspace_name='catalog.book_awards' ;
```
La sortie doit ressembler à ceci.
```
keyspace_name | table_name | bloom_filter_fp_chance | caching | cdc | comment | compaction | compression | crc_check_chance | dclocal_read_repair_chance | default_time_to_live | extensions | flags | gc_grace_seconds | id | max_index_interval | memtable_flush_period_in_ms | min_index_interval | read_repair_chance | speculative_retry
---------------+------------+------------------------+---------+-----+---------+------------+-------------+------------------+----------------------------+----------------------+------------+-------+------------------+----+--------------------+-----------------------------+--------------------+--------------------+-------------------
(0 rows)
```
1. Vérifiez la structure de votre table.
```
SELECT * FROM system_schema.columns WHERE keyspace_name = 'catalog' AND table_name = 'book_awards';
```
Le résultat de cette instruction doit ressembler à celui de cet exemple.
```
keyspace_name | table_name | column_name | clustering_order | column_name_bytes | kind | position | type
---------------+-------------+-------------+------------------+------------------------+---------------+----------+------
catalog | book_awards | year | none | 0x79656172 | partition_key | 0 | int
catalog | book_awards | award | none | 0x6177617264 | partition_key | 1 | text
catalog | book_awards | category | asc | 0x63617465676f7279 | clustering | 0 | text
catalog | book_awards | rank | asc | 0x72616e6b | clustering | 1 | int
catalog | book_awards | author | none | 0x617574686f72 | regular | -1 | text
catalog | book_awards | book_title | none | 0x626f6f6b5f7469746c65 | regular | -1 | text
catalog | book_awards | publisher | none | 0x7075626c6973686572 | regular | -1 | text
(7 rows)
```
Confirmez que toutes les colonnes et tous les types de données sont tels que vous l'escomptiez. L'ordre des colonnes peut être différent de celui de l'instruction `CREATE`.
## En utilisant le AWS CLI
Cette procédure crée une table avec les colonnes et les types de données suivants à l'aide du AWS CLI. Les `award` colonnes `year` et constituent la clé de partition avec `category` et en `rank` tant que colonnes de clustering.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Pour créer un tableau à l'aide du AWS CLI**
La commande suivante crée une table nommée *book\$1awards*. La clé de partition de la table comprend les colonnes `year` `award` et la clé de clustering les colonnes. Les deux colonnes `category` de `rank` clustering utilisent l'ordre de tri croissant. (Pour une meilleure lisibilité, la commande `schema-definition` de création de table de cette section est divisée en lignes distinctes.)
1. Vous pouvez créer le tableau à l'aide de l'instruction suivante.
```
aws keyspaces create-table --keyspace-name 'catalog' \
--table-name 'book_awards' \
--schema-definition 'allColumns=[{name=year,type=int},{name=award,type=text},{name=rank,type=int},
{name=category,type=text}, {name=author,type=text},{name=book_title,type=text},{name=publisher,type=text}],
partitionKeys=[{name=year},{name=award}],clusteringKeys=[{name=category,orderBy=ASC},{name=rank,orderBy=ASC}]'
```
Cette commande produit le résultat suivant.
```
{
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards"
}
```
1. Pour confirmer les métadonnées et les propriétés de la table, vous pouvez utiliser la commande suivante.
```
aws keyspaces get-table --keyspace-name 'catalog' --table-name 'book_awards'
```
Cette commande renvoie la sortie suivante.
```
{
"keyspaceName": "catalog",
"tableName": "book_awards",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards",
"creationTimestamp": "2024-07-11T15:12:55.571000+00:00",
"status": "ACTIVE",
"schemaDefinition": {
"allColumns": [
{
"name": "year",
"type": "int"
},
{
"name": "award",
"type": "text"
},
{
"name": "category",
"type": "text"
},
{
"name": "rank",
"type": "int"
},
{
"name": "author",
"type": "text"
},
{
"name": "book_title",
"type": "text"
},
{
"name": "publisher",
"type": "text"
}
],
"partitionKeys": [
{
"name": "year"
},
{
"name": "award"
}
],
"clusteringKeys": [
{
"name": "category",
"orderBy": "ASC"
},
{
"name": "rank",
"orderBy": "ASC"
}
],
"staticColumns": []
},
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST",
"lastUpdateToPayPerRequestTimestamp": "2024-07-11T15:12:55.571000+00:00"
},
"encryptionSpecification": {
"type": "AWS_OWNED_KMS_KEY"
},
"pointInTimeRecovery": {
"status": "DISABLED"
},
"defaultTimeToLive": 0,
"comment": {
"message": ""
},
"replicaSpecifications": []
}
```
Pour effectuer des opérations CRUD (création, lecture, mise à jour et suppression) sur les données de votre table, passez à [Création, lecture, mise à jour et suppression de données (CRUD) à l'aide de CQL dans Amazon Keyspaces](getting-started.dml.md).
# Vérifiez l'état de création des tables dans Amazon Keyspaces
Amazon Keyspaces exécute des opérations de langage de définition de données (DDL), telles que la création et la suppression de tables, de manière asynchrone. Vous pouvez surveiller l'état de création de nouvelles tables dans le AWS Management Console, qui indique si une table est en attente ou active. Vous pouvez également surveiller l'état de création d'une nouvelle table par programmation à l'aide de la table du schéma système.
Un tableau apparaît comme actif dans le schéma du système lorsqu'il est prêt à être utilisé. Le modèle de conception recommandé pour vérifier qu'une nouvelle table est prête à être utilisée consiste à interroger les tables de schéma du système Amazon Keyspaces ()`system_schema_mcs.*`. Pour obtenir la liste des instructions DDL pour les tables, consultez la [Tables](cql.ddl.table.md) section du manuel de référence du langage CQL.
La requête suivante indique le statut d'une table.
```
SELECT keyspace_name, table_name, status FROM system_schema_mcs.tables WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
Pour une table toujours en cours de création et en attente, le résultat de la requête ressemble à ceci.
```
keyspace_name | table_name | status
--------------+------------+--------
mykeyspace | mytable | CREATING
```
Pour une table qui a été créée avec succès et qui est active, le résultat de la requête est le suivant.
```
keyspace_name | table_name | status
--------------+------------+--------
mykeyspace | mytable | ACTIVE
```
# Création, lecture, mise à jour et suppression de données (CRUD) à l'aide de CQL dans Amazon Keyspaces
Dans cette étape du didacticiel, vous allez apprendre à insérer, lire, mettre à jour et supprimer des données dans une table Amazon Keyspaces à l'aide des instructions du langage de manipulation de données (DML) CQL. Dans Amazon Keyspaces, vous ne pouvez créer des instructions DML qu'en langage CQL. Dans ce didacticiel, vous allez vous entraîner à exécuter des instructions DML à l'aide de la commande `cqlsh-expansion` with [AWS CloudShell](using-aws-with-cloudshell.md)dans le AWS Management Console.
+ **Insertion de données** — Cette section traite de l'insertion d'un ou de plusieurs enregistrements dans une table à l'aide de l'`INSERT`instruction. Vous apprendrez à télécharger des données à partir d'un fichier CSV et à vérifier la réussite des insertions à l'aide de `SELECT` requêtes.
+ **Lecture de données** — Ici, vous allez explorer différentes variantes de l'`SELECT`instruction pour récupérer les données d'un tableau. Les sujets abordés incluent la sélection de toutes les données, la sélection de colonnes spécifiques, le filtrage des lignes en fonction des conditions à l'aide de la `WHERE` clause et la compréhension des conditions simples et composées.
+ **Mise à jour des données** : dans cette section, vous allez apprendre à modifier les données existantes d'un tableau à l'aide de l'`UPDATE`instruction. Vous vous entraînerez à mettre à jour une ou plusieurs colonnes tout en comprenant les restrictions liées à la mise à jour des colonnes de clé primaire.
+ **Suppression de données** — La dernière section traite de la suppression de données d'un tableau à l'aide de l'`DELETE`instruction. Vous découvrirez comment supprimer des cellules spécifiques, des lignes entières, et les implications de la suppression de données par rapport à la suppression de l'intégralité du tableau ou de l'espace-clé.
Tout au long du didacticiel, vous trouverez des exemples, des conseils et des opportunités pour vous entraîner à écrire vos propres requêtes CQL pour différents scénarios.
**Topics**
+ [
# Insertion et chargement de données dans un tableau Amazon Keyspaces
](getting-started.dml.create.md)
+ [
# Lire les données d'une table à l'aide de l'`SELECT`instruction CQL dans Amazon Keyspaces
](getting-started.dml.read.md)
+ [
# Mettre à jour les données d'une table Amazon Keyspaces à l'aide de CQL
](getting-started.dml.update.md)
+ [
# Supprimer les données d'une table à l'aide de l'instruction CQL `DELETE`
](getting-started.dml.delete.md)
# Insertion et chargement de données dans un tableau Amazon Keyspaces
Pour créer des données dans votre table `book_awards`, utilisez l'instruction `INSERT` pour ajouter une seule ligne.
1. Ouvrez AWS CloudShell et connectez-vous à Amazon Keyspaces à l'aide de la commande suivante. Assurez-vous d'effectuer la mise à jour *us-east-1* avec votre propre région.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
Le résultat de cette commande devrait ressembler à ceci.
```
Connected to Amazon Keyspaces at cassandra.us-east-1.amazonaws.com:9142
[cqlsh 6.1.0 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh current consistency level is ONE.
```
1. Avant de pouvoir écrire des données dans votre table Amazon Keyspaces à l'aide de cqlsh, vous devez définir la cohérence d'écriture de la session cqlsh en cours sur. `LOCAL_QUORUM` Pour plus d'informations sur les niveaux de cohérence pris en charge, consultez[Niveaux de cohérence en écriture](consistency.md#WriteConsistency). Notez que cette étape n'est pas obligatoire si vous utilisez l'éditeur CQL dans le AWS Management Console.
```
CONSISTENCY LOCAL_QUORUM;
```
1. Pour insérer un seul enregistrement, exécutez la commande suivante dans l'éditeur CQL.
```
INSERT INTO catalog.book_awards (award, year, category, rank, author, book_title, publisher)
VALUES ('Wolf', 2023, 'Fiction',3,'Shirley Rodriguez','Mountain', 'AnyPublisher') ;
```
1. Vérifiez que les données ont été correctement ajoutées à votre table en exécutant la commande suivante.
```
SELECT * FROM catalog.book_awards;
```
Le résultat de la déclaration doit ressembler à ceci.
```
year | award | category | rank | author | book_title | publisher
------+-------+----------+------+-------------------+------------+--------------
2023 | Wolf | Fiction | 3 | Shirley Rodriguez | Mountain | AnyPublisher
(1 rows)
```
**Pour insérer plusieurs enregistrements à partir d'un fichier avec cqlsh**
1. Téléchargez l'exemple de fichier CSV (`keyspaces_sample_table.csv`) contenu dans le fichier d'archive [samplemigration.zip](samples/samplemigration.zip). Décompressez l'archive et notez le chemin vers`keyspaces_sample_table.csv`.
![\[Capture d'écran d'un fichier CSV montrant le résultat du tableau après l'importation du fichier csv.\]](http://docs.aws.amazon.com/fr_fr/keyspaces/latest/devguide/images/keyspaces-awards.png)
1. Ouvrez AWS CloudShell AWS Management Console et connectez-vous à Amazon Keyspaces à l'aide de la commande suivante. Assurez-vous d'effectuer la mise à jour *us-east-1* avec votre propre région.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. À l'invite `cqlsh` (`cqlsh>`), spécifiez un keyspace.
```
USE catalog ;
```
1. Définissez la cohérence d'écriture sur`LOCAL_QUORUM`. Pour plus d'informations sur les niveaux de cohérence pris en charge, consultez[Niveaux de cohérence en écriture](consistency.md#WriteConsistency).
```
CONSISTENCY LOCAL_QUORUM;
```
1. Dans le AWS CloudShell menu **Actions** en haut à droite de l'écran, puis choisissez **Télécharger le fichier** pour télécharger le fichier csv téléchargé précédemment. Prenez note du chemin d'accès au fichier.
1. À l'invite keyspace (`cqlsh:catalog>`), exécutez l'instruction suivante.
```
COPY book_awards (award, year, category, rank, author, book_title, publisher) FROM '/home/cloudshell-user/keyspaces_sample_table.csv' WITH header=TRUE ;
```
Le résultat de l'instruction doit ressembler à ceci.
```
cqlsh:catalog> COPY book_awards (award, year, category, rank, author, book_title, publisher) FROM '/home/cloudshell-user/keyspaces_sample_table.csv' WITH delimiter=',' AND header=TRUE ;
cqlsh current consistency level is LOCAL_QUORUM.
Reading options from /home/cloudshell-user/.cassandra/cqlshrc:[copy]: {'numprocesses': '16', 'maxattempts': '1000'}
Reading options from /home/cloudshell-user/.cassandra/cqlshrc:[copy-from]: {'ingestrate': '1500', 'maxparseerrors': '1000', 'maxinserterrors': '-1', 'maxbatchsize': '10', 'minbatchsize': '1', 'chunksize': '30'}
Reading options from the command line: {'delimiter': ',', 'header': 'TRUE'}
Using 16 child processes
Starting copy of catalog.book_awards with columns [award, year, category, rank, author, book_title, publisher].
OSError: handle is closed 0 rows/s; Avg. rate: 0 rows/s
Processed: 9 rows; Rate: 0 rows/s; Avg. rate: 0 rows/s
9 rows imported from 1 files in 0 day, 0 hour, 0 minute, and 26.706 seconds (0 skipped).
```
1. Vérifiez que les données ont été correctement ajoutées à votre table en exécutant la requête suivante.
```
SELECT * FROM book_awards ;
```
Le résultat suivant doit s'afficher.
```
year | award | category | rank | author | book_title | publisher
------+------------------+-------------+------+--------------------+-----------------------+---------------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | Example Books
2020 | Wolf | Non-Fiction | 2 | Ana Carolina Silva | Science Today | SomePublisher
2020 | Wolf | Non-Fiction | 3 | Shirley Rodriguez | The Future of Sea Ice | AnyPublisher
2020 | Kwesi Manu Prize | Fiction | 1 | Akua Mansa | Where did you go? | SomePublisher
2020 | Kwesi Manu Prize | Fiction | 2 | John Stiles | Yesterday | Example Books
2020 | Kwesi Manu Prize | Fiction | 3 | Nikki Wolf | Moving to the Chateau | AnyPublisher
2020 | Richard Roe | Fiction | 1 | Alejandro Rosalez | Long Summer | SomePublisher
2020 | Richard Roe | Fiction | 2 | Arnav Desai | The Key | Example Books
2020 | Richard Roe | Fiction | 3 | Mateo Jackson | Inside the Whale | AnyPublisher
(9 rows)
```
Pour en savoir plus sur l'utilisation `cqlsh COPY` du téléchargement de données depuis des fichiers CSV vers une table Amazon Keyspaces, consultez. [Tutoriel : Chargement de données dans Amazon Keyspaces à l'aide de cqlsh](bulk-upload.md)
# Lire les données d'une table à l'aide de l'`SELECT`instruction CQL dans Amazon Keyspaces
Dans la section [Insertion et chargement de données dans un tableau Amazon Keyspaces](getting-started.dml.create.md), vous avez utilisé l'instruction `SELECT` pour vérifier que vous avez correctement ajouté des données à votre table. Dans cette section, vous affinez votre utilisation de `SELECT` pour afficher des colonnes spécifiques, et uniquement des lignes qui répondent à des critères spécifiques.
La forme générale de l'instruction `SELECT` est la suivante.
```
SELECT column_list FROM table_name [WHERE condition [ALLOW FILTERING]] ;
```
**Topics**
+ [
## Sélectionnez toutes les données de votre tableau
](#getting-started.dml.read.all)
+ [
## Sélectionnez un sous-ensemble de colonnes
](#getting-started.dml.read.columns)
+ [
## Sélectionnez un sous-ensemble de lignes
](#getting-started.dml.read.rows)
## Sélectionnez toutes les données de votre tableau
La forme la plus simple de l'instruction `SELECT` renvoie toutes les données de votre table.
**Important**
Dans un environnement de production, il n'est généralement pas recommandé d'exécuter cette commande, car elle renvoie toutes les données de votre table.
**Pour sélectionner toutes les données de votre table**
1. Ouvrez AWS CloudShell et connectez-vous à Amazon Keyspaces à l'aide de la commande suivante. Assurez-vous d'effectuer la mise à jour *us-east-1* avec votre propre région.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Exécutez la requête suivante :
```
SELECT * FROM catalog.book_awards ;
```
Utilisation du caractère générique (`*`) pour que `column_list` sélectionne toutes les colonnes. Le résultat de l'instruction ressemble à l'exemple suivant.
```
year | award | category | rank | author | book_title | publisher
------+------------------+-------------+------+--------------------+-----------------------+---------------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | AnyPublisher
2020 | Wolf | Non-Fiction | 2 | Ana Carolina Silva | Science Today | SomePublisher
2020 | Wolf | Non-Fiction | 3 | Shirley Rodriguez | The Future of Sea Ice | AnyPublisher
2020 | Kwesi Manu Prize | Fiction | 1 | Akua Mansa | Where did you go? | SomePublisher
2020 | Kwesi Manu Prize | Fiction | 2 | John Stiles | Yesterday | Example Books
2020 | Kwesi Manu Prize | Fiction | 3 | Nikki Wolf | Moving to the Chateau | AnyPublisher
2020 | Richard Roe | Fiction | 1 | Alejandro Rosalez | Long Summer | SomePublisher
2020 | Richard Roe | Fiction | 2 | Arnav Desai | The Key | Example Books
2020 | Richard Roe | Fiction | 3 | Mateo Jackson | Inside the Whale | AnyPublisher
```
## Sélectionnez un sous-ensemble de colonnes
**Pour interroger un sous-ensemble de colonnes**
1. Ouvrez AWS CloudShell et connectez-vous à Amazon Keyspaces à l'aide de la commande suivante. Assurez-vous d'effectuer la mise à jour *us-east-1* avec votre propre région.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Pour récupérer uniquement les colonnes `award`, `category` et `year`, exécutez la requête suivante.
```
SELECT award, category, year FROM catalog.book_awards ;
```
La sortie contient uniquement les colonnes spécifiées dans l'ordre indiqué dans l'`SELECT`instruction.
```
award | category | year
------------------+-------------+------
Wolf | Non-Fiction | 2020
Wolf | Non-Fiction | 2020
Wolf | Non-Fiction | 2020
Kwesi Manu Prize | Fiction | 2020
Kwesi Manu Prize | Fiction | 2020
Kwesi Manu Prize | Fiction | 2020
Richard Roe | Fiction | 2020
Richard Roe | Fiction | 2020
Richard Roe | Fiction | 2020
```
## Sélectionnez un sous-ensemble de lignes
Lors de l'interrogation d'un jeu de données volumineux, vous ne souhaitez peut-être que les enregistrements répondant à certains critères. Pour ce faire, vous pouvez ajouter une clause `WHERE` à la fin de notre instruction `SELECT`.
**Pour interroger un sous-ensemble de lignes**
1. Ouvrez AWS CloudShell et connectez-vous à Amazon Keyspaces à l'aide de la commande suivante. Assurez-vous d'effectuer la mise à jour *us-east-1* avec votre propre région.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Pour récupérer uniquement les dossiers relatifs aux récompenses d'une année donnée, exécutez la requête suivante.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Wolf' ;
```
L'`SELECT`instruction précédente renvoie le résultat suivant.
```
year | award | category | rank | author | book_title | publisher
------+-------+-------------+------+--------------------+-----------------------+---------------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | AnyPublisher
2020 | Wolf | Non-Fiction | 2 | Ana Carolina Silva | Science Today | SomePublisher
2020 | Wolf | Non-Fiction | 3 | Shirley Rodriguez | The Future of Sea Ice | AnyPublisher
```
### Comprendre la `WHERE` clause
La clause `WHERE` est utilisée pour filtrer les données et renvoyer uniquement celles qui répondent aux critères spécifiés. Les critères spécifiés peuvent être une condition simple ou une condition composée.
**Comment utiliser les conditions dans une clause `WHERE`**
+ Une condition simple : une seule colonne.
```
WHERE column_name=value
```
Vous pouvez utiliser une condition simple dans une clause `WHERE` si l'une des conditions suivantes est remplie :
+ La colonne est la seule colonne clé de partition de la table.
+ Vous ajoutez `ALLOW FILTERING` après la condition de la clause `WHERE`.
Sachez que l'utilisation d'`ALLOW FILTERING` peut entraîner des performances incohérentes, en particulier avec les tables volumineuses et à plusieurs partitions.
+ Une condition composée — Plusieurs conditions simples reliées par`AND`.
```
WHERE column_name1=value1 AND column_name2=value2 AND column_name3=value3...
```
Vous pouvez utiliser des conditions composées dans une clause `WHERE` si l'une des conditions suivantes est remplie :
+ Les colonnes que vous pouvez utiliser dans la `WHERE` clause doivent inclure la totalité ou un sous-ensemble des colonnes de la clé de partition de la table. Si vous souhaitez utiliser uniquement un sous-ensemble des colonnes de la `WHERE` clause, vous devez inclure un ensemble contigu de colonnes de clé de partition de gauche à droite, en commençant par la première colonne de la clé de partition. Par exemple, si les colonnes de clé de partition sont `year``month`,, `award` vous pouvez utiliser les colonnes suivantes dans la `WHERE` clause :
+ `year`
+ `year`ET `month`
+ `year`ET `month` ET `award`
+ Vous ajoutez `ALLOW FILTERING` après la condition composée dans la clause `WHERE`, comme dans l'exemple suivant.
```
SELECT * FROM my_table WHERE col1=5 AND col2='Bob' ALLOW FILTERING ;
```
Sachez que l'utilisation d'`ALLOW FILTERING` peut entraîner des performances incohérentes, en particulier avec les tables volumineuses et à plusieurs partitions.
### Essayez-le
Créez vos propres requêtes CQL pour trouver les éléments suivants dans votre table `book_awards` :
+ Trouvez les gagnants des Wolf Awards 2020 et affichez les titres et les auteurs des livres, classés par rang.
+ Afficher les premiers gagnants de tous les prix en 2020 et afficher les titres des livres et les noms des récompenses.
# Mettre à jour les données d'une table Amazon Keyspaces à l'aide de CQL
Pour mettre à jour les données de votre table `book_awards`, utilisez l'instruction `UPDATE`.
La forme générale de l'instruction `UPDATE` est la suivante.
```
UPDATE table_name SET column_name=new_value WHERE primary_key=value ;
```
**Astuce**
Vous pouvez mettre à jour plusieurs colonnes à l'aide d'une liste de `column_names` et de valeurs séparées par des virgules, comme dans l'exemple suivant.
```
UPDATE my_table SET col1='new_value_1', col2='new_value2' WHERE col3='1' ;
```
Si la clé primaire est composée de plusieurs colonnes, toutes les colonnes de clé primaire et leurs valeurs doivent être incluses dans la clause `WHERE`.
Vous ne pouvez pas mettre à jour une colonne de la clé primaire car cela modifierait la clé primaire de l'enregistrement.
**Pour mettre à jour une cellule unique**
À l'aide de votre `book_awards` tableau, changez le nom d'un éditeur pour le gagnant des Wolf Awards, œuvres non fictionnelles, en 2020.
```
UPDATE book_awards SET publisher='new Books' WHERE year = 2020 AND award='Wolf' AND category='Non-Fiction' AND rank=1;
```
Vérifiez que l'éditeur l'est maintenant`new Books`.
```
SELECT * FROM book_awards WHERE year = 2020 AND award='Wolf' AND category='Non-Fiction' AND rank=1;
```
L'instruction doit renvoyer le résultat suivant.
```
year | award | category | rank | author | book_title | publisher
------+-------+-------------+------+-------------+------------------+-----------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | new Books
```
## Essayez-le
**Niveau avancé :** Le gagnant du prix de fiction « Kwezi Manu » 2020 a changé de nom. Mettez à jour cet enregistrement pour changer le nom en`'Akua Mansa-House'`.
# Supprimer les données d'une table à l'aide de l'instruction CQL `DELETE`
Pour supprimer les données de votre table `book_awards`, utilisez l'instruction `DELETE`.
Vous pouvez supprimer des données d'une ligne ou d'une partition. Soyez prudent lorsque vous supprimez des données, car les suppressions sont irréversibles.
La suppression d'une ou de toutes les lignes d'un tableau n'entraîne pas la suppression du tableau. Ainsi, vous pouvez le remplir à nouveau avec des données. La suppression d'une table supprime la table et toutes les données qu'elle contient. Pour réutiliser la table, vous devez la recréer et y ajouter des données. La suppression d'un keyspace supprime le keyspace et toutes les tables qu'il contient. Pour utiliser le keyspace et les tables, vous devez les recréer, puis les remplir avec des données. Vous pouvez utiliser Amazon Keyspaces Point-in-time (PITR) Recovery pour restaurer les tables supprimées. Pour en savoir plus, consultez. [Backup et restauration des données avec point-in-time restauration pour Amazon Keyspaces](PointInTimeRecovery.md) Pour savoir comment restaurer une table supprimée lorsque le PITR est activé, consultez[Restaurer une table supprimée à l'aide d'Amazon Keyspaces PITR](restoredeleted.md).
## Supprimer des cellules
La suppression d'une colonne d'une ligne supprime les données de la cellule spécifiée. Lorsque vous affichez cette colonne à l'aide d'une `SELECT` instruction, les données sont affichées sous forme*null*, bien qu'aucune valeur nulle ne soit stockée à cet emplacement.
La syntaxe générale permettant de supprimer une ou plusieurs colonnes spécifiques est la suivante.
```
DELETE column_name1[, column_name2...] FROM table_name WHERE condition ;
```
Dans votre `book_awards` tableau, vous pouvez voir que le titre du livre qui a remporté le premier prix du prix « Richard Roe » 2020 est « Long Summer ». Imaginez que ce titre ait été rappelé et que vous deviez supprimer les données de cette cellule.
**Pour supprimer une cellule spécifique**
1. Ouvrez AWS CloudShell et connectez-vous à Amazon Keyspaces à l'aide de la commande suivante. Assurez-vous d'effectuer la mise à jour *us-east-1* avec votre propre région.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Exécutez la requête `DELETE` suivante :
```
DELETE book_title FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
1. Vérifiez que la demande de suppression a été effectuée comme prévu.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
Le résultat de cette instruction ressemble à ceci.
```
year | award | category | rank | author | book_title | publisher
------+-------------+----------+------+-------------------+------------+---------------
2020 | Richard Roe | Fiction | 1 | Alejandro Rosalez | null | SomePublisher
```
## Supprimer les lignes
Il peut arriver que vous deviez supprimer une ligne entière, par exemple pour répondre à une demande de suppression de données. La syntaxe générale pour supprimer une ligne est la suivante.
```
DELETE FROM table_name WHERE condition ;
```
**Pour supprimer une ligne**
1. Ouvrez AWS CloudShell et connectez-vous à Amazon Keyspaces à l'aide de la commande suivante. Assurez-vous d'effectuer la mise à jour *us-east-1* avec votre propre région.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Exécutez la requête `DELETE` suivante :
```
DELETE FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
1. Vérifiez que la suppression a été effectuée comme prévu.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
Le résultat de cette instruction ressemble à ceci une fois la ligne supprimée.
```
year | award | category | rank | author | book_title | publisher
------+-------+----------+------+--------+------------+-----------
(0 rows)
```
Vous pouvez supprimer automatiquement les données expirées de votre tableau à l'aide d'Amazon Keyspaces Time to Live. Pour plus d'informations, consultez. [Expirer les données avec Time to Live (TTL) pour Amazon Keyspaces (pour Apache Cassandra)](TTL.md)
# Supprimer un tableau dans Amazon Keyspaces
Pour éviter d'être facturé pour des tables et des données dont vous n'avez pas besoin, supprimez toutes les tables que vous n'utilisez pas. Lorsque vous supprimez une table, la table et ses données sont supprimées et vous arrêtez d'accumuler des frais pour eux. Cependant, le keyspace demeure. Lorsque vous supprimez un keyspace, le keyspace et toutes ses tables sont supprimés et vous cessez d'accumuler des frais pour eux.
Vous pouvez supprimer une table à l'aide de la console, du CQL ou du AWS CLI. Lorsque vous supprimez une table, la table et toutes ses données sont supprimées.
## Utilisation de la console
La procédure suivante supprime une table et toutes ses données avec AWS Management Console.
**Pour supprimer une table à l'aide de la console**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Dans le volet de navigation, choisissez **Tables**.
1. Sélectionnez la case située à gauche du nom de chaque table à supprimer.
1. Sélectionnez **Delete (Supprimer)**.
1. Dans l'écran **Supprimer la table** entrez **Delete** dans la zone. Puis, choisissez **Delete Table (Supprimer la table)**.
1. Pour vérifier que la table a été supprimée, choisissez **Tables** dans le panneau de navigation et vérifiez que la table `book_awards` n'est plus répertoriée.
## Utilisation de CQL
La procédure suivante supprime une table et toutes ses données à l'aide de CQL.
**Pour supprimer une table avec CQL**
1. Ouvrez AWS CloudShell et connectez-vous à Amazon Keyspaces à l'aide de la commande suivante. Assurez-vous d'effectuer la mise à jour *us-east-1* avec votre propre région.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Supprimez votre tableau en saisissant l'instruction suivante.
```
DROP TABLE IF EXISTS catalog.book_awards ;
```
1. Vérifiez que votre table a été supprimée.
```
SELECT * FROM system_schema.tables WHERE keyspace_name = 'catalog' ;
```
La sortie doit ressembler à ceci. Notez que cela peut prendre un certain temps, alors réexécutez l'instruction au bout d'une minute si vous ne voyez pas ce résultat.
```
keyspace_name | table_name | bloom_filter_fp_chance | caching | cdc | comment | compaction | compression | crc_check_chance | dclocal_read_repair_chance | default_time_to_live | extensions | flags | gc_grace_seconds | id | max_index_interval | memtable_flush_period_in_ms | min_index_interval | read_repair_chance | speculative_retry
---------------+------------+------------------------+---------+-----+---------+------------+-------------+------------------+----------------------------+----------------------+------------+-------+------------------+----+--------------------+-----------------------------+--------------------+--------------------+-------------------
(0 rows)
```
## En utilisant le AWS CLI
La procédure suivante supprime une table et toutes ses données avec AWS CLI.
**Pour supprimer un tableau à l'aide du AWS CLI**
1. Ouvert CloudShell
1. Supprimez votre tableau avec l'instruction suivante.
```
aws keyspaces delete-table --keyspace-name 'catalog' --table-name 'book_awards'
```
1. Pour vérifier que votre table a été supprimée, vous pouvez répertorier toutes les tables dans un espace de touches.
```
aws keyspaces list-tables --keyspace-name 'catalog'
```
Le résultat suivant doit s'afficher. Notez que cette opération asynchrone peut prendre un certain temps. Exécutez à nouveau la commande après un court instant pour confirmer que la table a été supprimée.
```
{
"tables": []
}
```
# Supprimer un espace de touches dans Amazon Keyspaces
Pour éviter d'être facturé pour les espaces de touches, supprimez tous les espaces de touches que vous n'utilisez pas. Lorsque vous supprimez un keyspace, le keyspace et toutes ses tables sont supprimés et vous cessez d'accumuler des frais pour eux.
Vous pouvez supprimer un espace de touches à l'aide de la console, du CQL ou du. AWS CLI
## Utilisation de la console
La procédure suivante permet de supprimer un espace de touches ainsi que toutes ses tables et données à l'aide de la console.
**Pour supprimer un keyspace à l'aide de la console**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Dans le panneau de navigation, choisissez **Keyspaces**.
1. Sélectionnez la case située à gauche du nom de chaque keyspace que vous souhaitez supprimer.
1. Sélectionnez **Delete (Supprimer)**.
1. Dans l'écran **Supprimer le keyspace** entrez **Delete** dans la zone. Ensuite, choisissez **Supprimer le keyspace**.
1. Pour vérifier que le keyspace `catalog` a été supprimé, choisissez **Keyspaces** dans le panneau de navigation et vérifiez qu'il n'est plus répertorié. Étant donné que vous avez supprimé son keyspace, la table `book_awards` sous **Tables** ne doit pas non plus être répertoriée.
## Utilisation de CQL
La procédure suivante supprime un keyspace et toutes ses tables et données à l'aide de CQL.
**Pour supprimer un keyspace avec CQL**
1. Ouvrez AWS CloudShell et connectez-vous à Amazon Keyspaces à l'aide de la commande suivante. Assurez-vous d'effectuer la mise à jour *us-east-1* avec votre propre région.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Supprimez votre espace de touche en saisissant l'instruction suivante.
```
DROP KEYSPACE IF EXISTS catalog ;
```
1. Vérifiez que votre keyspace a été supprimé.
```
SELECT * from system_schema.keyspaces ;
```
Votre keyspace ne doit pas être répertorié. Notez qu'étant donné qu'il s'agit d'une opération asynchrone, il peut y avoir un délai avant que le keyspace ne soit supprimé. Une fois le keyspace supprimé, le résultat de l'instruction devrait ressembler à ceci.
```
keyspace_name | durable_writes | replication
-------------------------+----------------+-------------------------------------------------------------------------------------
system_schema | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_schema_mcs | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_multiregion_info | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
(4 rows)
```
## En utilisant le AWS CLI
La procédure suivante supprime un keyspace ainsi que toutes ses tables et données avec AWS CLI.
**Pour supprimer un espace-touche à l'aide du AWS CLI**
1. Ouvert AWS CloudShell
1. Supprimez votre espace de touche en saisissant l'instruction suivante.
```
aws keyspaces delete-keyspace --keyspace-name 'catalog'
```
1. Vérifiez que votre keyspace a été supprimé.
```
aws keyspaces list-keyspaces
```
Le résultat de cette instruction doit ressembler à ceci et ne répertorier que les espaces de touches du système. Notez qu'étant donné qu'il s'agit d'une opération asynchrone, il peut y avoir un délai avant que votre espace de touches ne soit supprimé.
```
{
"keyspaces": [
{
"keyspaceName": "system_schema",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system_schema/",
"replicationStrategy": "SINGLE_REGION"
},
{
"keyspaceName": "system_schema_mcs",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system_schema_mcs/",
"replicationStrategy": "SINGLE_REGION"
},
{
"keyspaceName": "system",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system/",
"replicationStrategy": "SINGLE_REGION"
},
{
"keyspaceName": "system_multiregion_info",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system_multiregion_info/",
"replicationStrategy": "SINGLE_REGION"
}
]
}
```