Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Introducción a Amazon Keyspaces (para Apache Cassandra)
Si es la primera vez que utiliza Apache Cassandra y Amazon Keyspaces, este tutorial le indicará cómo instalar los programas y herramientas necesarios para utilizar Amazon Keyspaces correctamente. Aprenderás a crear un espacio de claves y una tabla con Cassandra Query Language (CQL), the o Consola de administración de AWS the AWS Command Line Interface ().AWS CLI A continuación, utilizará Cassandra Query Language (CQL) para realizar operaciones de creación, lectura, actualización y eliminación (CRUD) de datos en la tabla de Amazon Keyspaces.
Este tutorial abarca los siguientes pasos.
+ **Requisitos previos**: antes de comenzar el tutorial, siga las instrucciones de AWS configuración para registrarse AWS y crear un usuario de IAM con acceso a Amazon Keyspaces. A continuación, configura y. `cqhsh-expansion` AWS CloudShell Como alternativa, puede utilizarlos AWS CLI para crear recursos en Amazon Keyspaces.
+ **Paso 1: creación de un espacio de claves y una tabla**; en esta sección, creará un espacio de claves denominado “catalog” y una tabla denominada “book\$1awards” dentro de él. Especificará las columnas, los tipos de datos, la clave de partición y la columna de agrupamiento de la tabla mediante el Consola de administración de AWS CQL o el. AWS CLI
+ **Paso 2: Realizar operaciones CRUD**: aquí, utilizará la `cqlsh-expansion` entrada CloudShell para insertar, leer, actualizar y eliminar datos de la tabla «book\$1awards». Aprenderá a usar varias instrucciones CQL, como SELECT, INSERT, UPDATE y DELETE, y practicará el filtrado y la modificación de datos.
+ **Paso 3: limpieza de los recursos**; para evitar incurrir en cargos por los recursos no utilizados, en esta sección se explica cómo eliminar la tabla “book\$1awards” y el espacio de claves del “catalog” mediante la consola, CQL o la AWS CLI.
Para ver tutoriales para conectarse mediante programación a Amazon Keyspaces utilizando diferentes controladores de cliente de Apache Cassandra, consulte [Uso de un controlador de cliente de Cassandra para acceder a Amazon Keyspaces mediante programación](programmatic.drivers.md). Para ver ejemplos de código que utilizan diferentes AWS SDKs, consulte [Ejemplos de código para el uso de Amazon Keyspaces](https://docs.aws.amazon.com/keyspaces/latest/devguide/service_code_examples.html). AWS SDKs
**Topics**
+ [
# Requisitos y consideraciones previos del tutorial
](getting-started.before-you-begin.md)
+ [
# Creación de un espacio de claves en Amazon Keyspaces.
](getting-started.keyspaces.md)
+ [
# Comprobación del estado de creación de los espacios de claves en Amazon Keyspaces
](keyspaces-create.md)
+ [
# Creación de un espacio de claves en Amazon Keyspaces
](getting-started.tables.md)
+ [
# Comprobación del estado de creación de las tablas en Amazon Keyspaces
](tables-create.md)
+ [
# Creación, lectura, actualización y eliminación de datos (CRUD) mediante CQL en Amazon Keyspaces
](getting-started.dml.md)
+ [
# Eliminación de una tabla en Amazon Keyspaces
](getting-started.clean-up.table.md)
+ [
# Eliminación de un espacio de claves en Amazon Keyspaces
](getting-started.clean-up.keyspace.md)
# Requisitos y consideraciones previos del tutorial
Antes de empezar a utilizar Amazon Keyspaces, sigue las instrucciones de AWS configuración que se indican en. [Acceso a Amazon Keyspaces (para Apache Cassandra)](accessing.md) Estos pasos incluyen registrarse AWS y crear un usuario AWS Identity and Access Management (IAM) con acceso a Amazon Keyspaces.
Para completar todos los pasos del tutorial, necesitará instalar `cqlsh`. Puede seguir las instrucciones de configuración de [Uso de `cqlsh` para conectarse a Amazon Keyspaces](programmatic.cqlsh.md).
Para acceder a Amazon Keyspaces mediante `cqlsh` o el AWS CLI, le recomendamos que utilice. AWS CloudShell CloudShelles un shell preautenticado y basado en un navegador que se puede iniciar directamente desde. Consola de administración de AWS Puede ejecutar comandos AWS Command Line Interface (AWS CLI) en Amazon Keyspaces utilizando el shell que prefiera (Bash PowerShell o Z shell). Para usar `cqlsh`, debe instalar la `cqlsh-expansion`. Para ver las instrucciones de instalación de `cqlsh-expansion`, consulte [Uso de la `cqlsh-expansion` para conectarse a Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh). Para obtener más información al respecto, consulte CloudShell . [Utilización AWS CloudShell para acceder a Amazon Keyspaces](using-aws-with-cloudshell.md)
Para usar el AWS CLI para crear, ver y eliminar recursos en Amazon Keyspaces, siga las instrucciones de configuración que se encuentran en. [Descargar y configurar el AWS CLI](access.cli.md#access.cli.installcli)
Tras completar los pasos de requisitos previos, continúe con [Creación de un espacio de claves en Amazon Keyspaces.](getting-started.keyspaces.md).
# Creación de un espacio de claves en Amazon Keyspaces.
En esta sección, creará un espacio de claves utilizando la consola, `cqlsh` o la AWS CLI.
**nota**
Antes de comenzar, asegúrese de haber configurado todos los [requisitos previos del tutorial](getting-started.before-you-begin.md).
Un *espacio de claves* agrupa tablas relacionadas que son relevantes para una o más aplicaciones. Un espacio de claves contiene una o varias tablas y define la estrategia de réplica para todas las tablas que contiene. Para obtener más información sobre los espacios de claves, consulte los siguientes temas:
+ Instrucciones en el lenguaje de definición de datos (DDL) en la referencia del lenguaje CQL: [Keyspaces](cql.ddl.keyspace.md)
+ [Cuotas para Amazon Keyspaces (para Apache Cassandra)](quotas.md)
En este tutorial, crearemos un espacio de claves de una sola región y la estrategia de replicación del espacio de claves es `SingleRegionStrategy`. Con `SingleRegionStrategy`, Amazon Keyspaces replica los datos en tres [zonas de disponibilidad](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/) en una Región de AWS. Para aprender a crear claves de varias regiones, consulte [Creación de un espacio de claves multirregional en Amazon Keyspaces](keyspaces-mrr-create.md).
## Uso de la consola
**Para crear un espacio de claves con la consola**
1. [Inicia sesión en la Consola de administración de AWS consola de Amazon Keyspaces y ábrela desde casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. En el panel de navegación, elija **Espacios de claves**.
1. Elija **Crear espacio de claves**.
1. En el cuadro **Nombre del espacio de claves**, introduzca **catalog** como nombre para su espacio de claves.
**Restricciones del nombre:**
+ El nombre no puede estar vacío.
+ Caracteres permitidos: alfanuméricos y guion bajo (`_`).
+ La longitud máxima es de 48 caracteres.
1. En **Regiones de AWS**, confirme que la **replicación en una sola región** sea la estrategia de replicación del espacio de claves.
1. Para crear el espacio de claves, elija **Crear espacio de claves**.
1. Para verificar que el espacio de claves `catalog` se haya creado, haga lo siguiente:
1. En el panel de navegación, elija **Espacios de claves**.
1. Localice su espacio de claves `catalog` en la lista de espacios de claves.
## Uso de CQL
El siguiente procedimiento crea un espacio de claves utilizando CQL.
**Para crear un espacio de claves con CQL**
1. Abre Amazon Keyspaces AWS CloudShell y conéctate a ellos mediante el siguiente comando. Asegúrese de actualizar *us-east-1* con su propia región.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
La salida de ese comando debería tener este aspecto.
```
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. Cree su espacio de claves utilizando el siguiente comando CQL.
```
CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
`SingleRegionStrategy`utiliza un factor de replicación de tres y replica los datos en tres zonas de AWS disponibilidad de su región.
**nota**
Amazon Keyspaces pone de forma predeterminada todas las entradas en minúsculas a menos que las encierre entre comillas.
1. Compruebe que se haya creado su espacio de claves.
```
SELECT * from system_schema.keyspaces;
```
La salida de este comando debería ser similar a la siguiente.
```
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)
```
## Usando el AWS CLI
El siguiente procedimiento crea un espacio de claves utilizando la AWS CLI.
**Para crear un espacio de claves mediante el AWS CLI**
1. Para confirmar que su entorno está configurado, puede ejecutar el siguiente comando en CloudShell.
```
aws keyspaces help
```
1. Cree su espacio de claves mediante la siguiente AWS CLI instrucción.
```
aws keyspaces create-keyspace --keyspace-name 'catalog'
```
1. Compruebe que el espacio de claves se haya creado con la siguiente declaración AWS CLI
```
aws keyspaces get-keyspace --keyspace-name 'catalog'
```
La salida de este comando debería tener un aspecto similar al de este ejemplo.
```
{
"keyspaceName": "catalog",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/",
"replicationStrategy": "SINGLE_REGION"
}
```
# Comprobación del estado de creación de los espacios de claves en Amazon Keyspaces
Amazon Keyspaces realiza las operaciones de lenguaje de definición de datos (DDL), como crear y eliminar espacios de claves, de forma asíncrona.
Puede supervisar el estado de creación de los nuevos espacios clave en el Consola de administración de AWS, lo que indica si un espacio clave está pendiente o activo. También puede monitorear el estado de creación de un nuevo espacio de claves mediante programación utilizando el espacio de claves `system_schema_mcs`. Un espacio de claves se hace visible en la tabla `system_schema_mcs` `keyspaces` cuando está listo para su uso.
El patrón de diseño recomendado para comprobar cuándo un nuevo espacio de claves está listo para su uso es sondear las tablas `system_schema_mcs` `keyspaces` de Amazon Keyspaces (system\$1schema\$1mcs.\$1). Para obtener una lista de las instrucciones DDL para espacios de claves, consulte la sección [Keyspaces](cql.ddl.keyspace.md) en la referencia del lenguaje CQL.
La siguiente consulta muestra si un espacio de claves se ha creado correctamente.
```
SELECT * FROM system_schema_mcs.keyspaces WHERE keyspace_name = 'mykeyspace';
```
Si un espacio de claves se ha creado correctamente, la salida de la consulta tiene el siguiente aspecto.
```
keyspace_name | durable_writes | replication
--------------+-----------------+--------------
mykeyspace | true |{...} 1 item
```
# Creación de un espacio de claves en Amazon Keyspaces
En este paso, creará una tabla utilizando la consola, `cqlsh` o la AWS CLI.
Una tabla es el lugar donde se organizan y almacenan sus datos. La clave principal de su tabla determina cómo se particionan los datos en la tabla. La clave principal se compone de una clave de partición obligatoria y una o varias columnas de agrupación opcionales. Los valores combinados que componen la clave principal deben ser únicos en todos los datos de la tabla. Para obtener más información sobre las tablas, consulte los siguientes temas:
+ Diseño de claves de partición: [Uso eficaz de las claves de partición en Amazon Keyspaces](bp-partition-key-design.md)
+ Uso de tablas: [Comprobación del estado de creación de las tablas en Amazon Keyspaces](tables-create.md)
+ Instrucciones DDL en la referencia del lenguaje CQL: [Tablas](cql.ddl.table.md)
+ Administración de recursos de la tabla: [Administración de recursos sin servidor en Amazon Keyspaces (para Apache Cassandra)](serverless_resource_management.md)
+ Monitoreo de utilización de recursos de la tabla: [Supervisión de Amazon Keyspaces con Amazon CloudWatch](monitoring-cloudwatch.md)
+ [Cuotas para Amazon Keyspaces (para Apache Cassandra)](quotas.md)
Al crear una tabla, especifica lo siguiente:
+ El nombre de la tabla.
+ El nombre y el tipo de datos de cada columna de la tabla.
+ La clave principal de la tabla.
+ **Clave de partición**: obligatorio
+ **Columnas de agrupación**: opcional
Utilice el siguiente procedimiento para crear una tabla con las columnas, los tipos de datos, las claves de partición y las columnas de agrupación especificados.
## Uso de la consola
El siguiente procedimiento crea la tabla `book_awards` con estas columnas y tipos de datos.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Para crear una tabla con la consola**
1. [Inicia sesión en la Consola de administración de AWS consola de Amazon Keyspaces y ábrela desde casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. En el panel de navegación, elija **Espacios de claves**.
1. Elija `catalog` como el espacio de claves en el que desea crear esta tabla.
1. Seleccione **Create table (Creación de tabla)**.
1. En el cuadro **Nombre de la tabla**, introduzca **book\$1awards** como nombre para la tabla.
**Restricciones del nombre:**
+ El nombre no puede estar vacío.
+ Caracteres permitidos: alfanuméricos y guion bajo (`_`).
+ La longitud máxima es de 48 caracteres.
1. En la sección **Columnas**, repita los siguientes pasos para cada columna que desee añadir a esta tabla.
Añada las columnas y tipos de datos siguientes.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
1. **Nombre**: introduzca un nombre para la columna.
**Restricciones del nombre:**
+ El nombre no puede estar vacío.
+ Caracteres permitidos: alfanuméricos y guion bajo (`_`).
+ La longitud máxima es de 48 caracteres.
1. **Tipo**: en la lista de tipos de datos, elija el tipo de datos para esta columna.
1. Para añadir una columna, elija **Agregar columna**.
1. Elija `award` y `year` como claves de partición en **Clave de partición**. Se necesita una clave de partición para cada tabla. Una clave de partición puede estar formada por una o más columnas.
1. Añada `category` y `rank` como **Columnas de agrupación en clústeres**. Las columnas de agrupación son opcionales y determinan el orden de clasificación dentro de cada partición.
1. Para añadir una columna de agrupación, elija **Agregar columnas de agrupación en clústeres**.
1. En la lista **Columnas**, elija la **categoría**. En la lista **Orden**, elija **ASC** para clasificar en orden ascendente los valores de esta columna. (Elija **DESC** para orden descendente).
1. A continuación, seleccione **Agregar columnas de agrupación en clústeres** y elija el **rango**.
1. En la sección **Configuración de la tabla**, elija **Configuración predeterminada**.
1. Seleccione **Create table (Creación de tabla)**.
1. Verifique que se haya creado su tabla.
1. En el panel de navegación, elija **Tablas**.
1. Confirme que su tabla se encuentre en la lista de tablas.
1. Elija el nombre de su tabla.
1. Confirme que todas sus columnas y tipos de datos sean correctos.
**nota**
Es posible que las columnas no aparezcan en el mismo orden en que las añadió a la tabla.
## Uso de CQL
Este procedimiento crea una tabla con las siguientes columnas y tipos de datos utilizando CQL. Las columnas `year` y `award` son claves de partición con `category` y `rank` como columnas de agrupación en clústeres, juntas forman la clave principal de la tabla.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Para crear una tabla utilizando CQL**
1. Abre Amazon Keyspaces AWS CloudShell y conéctate a ellos mediante el siguiente comando. Asegúrese de actualizar *us-east-1* con su propia región.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
La salida de ese comando debería tener este aspecto.
```
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. En la línea de comandos del espacio de claves (`cqlsh:keyspace_name>`), cree su tabla introduciendo el siguiente código en su ventana de comandos.
```
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)
);
```
**nota**
`ASC` es el orden de agrupación predeterminado. También puede especificar `DESC` para el orden descendente.
Tenga en cuenta que `year` y `award` son columnas de las claves de partición. Además, `category` y `rank` son las columnas de agrupación colocadas por orden ascendente (`ASC`). Juntas, estas columnas forman la clave principal de la tabla.
1. Verifique que se haya creado su tabla.
```
SELECT * from system_schema.tables WHERE keyspace_name='catalog.book_awards' ;
```
La salida debería ser similar a la siguiente.
```
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. Verifique la estructura de su tabla.
```
SELECT * FROM system_schema.columns WHERE keyspace_name = 'catalog' AND table_name = 'book_awards';
```
La salida de esta instrucción debe ser similar al siguiente ejemplo.
```
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)
```
Confirme que todas las columnas y tipos de datos sean los deseados. El orden de las columnas podría diferir al de la instrucción `CREATE`.
## Usando el AWS CLI
El siguiente procedimiento crea una tabla con las siguientes columnas y tipos de datos utilizando la AWS CLI. Las columnas `year` y `award` componen la clave de partición con `category` y `rank` como columnas de agrupación en clústeres.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Para crear una tabla mediante el AWS CLI**
El siguiente comando crea una tabla con el nombre *book\$1awards*. La clave de partición de la tabla está formada por las columnas `year` y `award` y la clave de agrupación está formada por las columnas `category` y `rank`; ambas columnas de agrupación utilizan el orden de clasificación ascendente. (Para facilitar la legibilidad, la `schema-definition` del comando de creación de tabla de esta sección se divide en líneas separadas).
1. Puede crear la tabla con la siguiente instrucción.
```
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}]'
```
Este comando da como resultado la siguiente salida.
```
{
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards"
}
```
1. Para confirmar los metadatos y las propiedades de la tabla, puede utilizar el siguiente comando.
```
aws keyspaces get-table --keyspace-name 'catalog' --table-name 'book_awards'
```
Este comando devuelve la siguiente salida.
```
{
"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": []
}
```
Para realizar operaciones CRUD (crear, leer, actualizar y eliminar) en los datos de su tabla, vaya a [Creación, lectura, actualización y eliminación de datos (CRUD) mediante CQL en Amazon Keyspaces](getting-started.dml.md).
# Comprobación del estado de creación de las tablas en Amazon Keyspaces
Amazon Keyspaces realiza operaciones de lenguaje de definición de datos (DDL), como crear y eliminar tablas, de forma asíncrona. Puede supervisar el estado de creación de nuevas tablas en el Consola de administración de AWS, lo que indica si una tabla está pendiente o activa. También puede monitorear el estado de creación de una nueva tabla mediante programación utilizando la tabla de esquema del sistema.
Una tabla aparece como activa en el esquema del sistema cuando está lista para su uso. El patrón de diseño recomendado para comprobar cuándo una nueva tabla está lista para su uso es sondear las tablas de esquema del sistema de Amazon Keyspaces (`system_schema_mcs.*`). Para obtener una lista de instrucciones DDL para tablas, consulte la sección [Tablas](cql.ddl.table.md) en la referencia del lenguaje CQL.
La siguiente consulta muestra el estado de una tabla.
```
SELECT keyspace_name, table_name, status FROM system_schema_mcs.tables WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
Para una tabla que todavía se esté creando y esté pendiente, la salida de la consulta tiene este aspecto.
```
keyspace_name | table_name | status
--------------+------------+--------
mykeyspace | mytable | CREATING
```
Para una tabla que se haya creado correctamente y esté activa, la salida de la consulta tiene el siguiente aspecto.
```
keyspace_name | table_name | status
--------------+------------+--------
mykeyspace | mytable | ACTIVE
```
# Creación, lectura, actualización y eliminación de datos (CRUD) mediante CQL en Amazon Keyspaces
En este paso del tutorial, aprenderá a insertar, leer, actualizar y eliminar datos en una tabla de Amazon Keyspaces mediante instrucciones en el lenguaje de manipulación de datos (DML) de CQL. En Amazon Keyspaces, solo puede crear instrucciones DML en lenguaje CQL. En este tutorial, practicará la ejecución de instrucciones DML utilizando la `cqlsh-expansion` con [AWS CloudShell](using-aws-with-cloudshell.md) en la Consola de administración de AWS.
+ **Inserción de datos**: en esta sección se describe la inserción de registros individuales y múltiples en una tabla mediante la instrucción `INSERT`. Aprenderá a cargar datos desde un archivo CSV y a comprobar que las inserciones se hayan realizado correctamente mediante consultas `SELECT`.
+ **Lectura de datos**: aquí explorará diferentes variaciones de la instrucción `SELECT` para recuperar datos de una tabla. Entre los temas se incluyen la selección de todos los datos, la selección de columnas específicas, el filtrado de filas en función de las condiciones mediante la cláusula `WHERE` y la comprensión de las condiciones simples y compuestas.
+ **Actualización de datos**: en esta sección, aprenderá a modificar los datos existentes en una tabla mediante la instrucción `UPDATE`. Practicará la actualización de columnas únicas y múltiples y, al mismo tiempo, comprenderá las restricciones relativas a la actualización de las columnas de clave principal.
+ **Eliminación de datos**: la última sección trata sobre la eliminación de datos de una tabla mediante la instrucción `DELETE`. Aprenderá a eliminar celdas específicas y filas enteras y verá cuáles son las implicaciones de eliminar datos en lugar de eliminar toda la tabla o todo el espacio de claves.
A lo largo del tutorial, encontrará ejemplos, consejos y oportunidades para practicar cómo escribir sus propias consultas CQL para distintos escenarios.
**Topics**
+ [
# Inserción y carga de datos en una tabla de Amazon Keyspaces
](getting-started.dml.create.md)
+ [
# Lectura de los datos de una tabla con la instrucción CQL `SELECT` en Amazon Keyspaces
](getting-started.dml.read.md)
+ [
# Actualización de datos en una tabla de Amazon Keyspaces con CQL
](getting-started.dml.update.md)
+ [
# Eliminación de los datos de una tabla mediante la sentencia CQL `DELETE`
](getting-started.dml.delete.md)
# Inserción y carga de datos en una tabla de Amazon Keyspaces
Para crear datos en su tabla `book_awards`, utilice la instrucción `INSERT` para añadir una única fila.
1. Abre Amazon Keyspaces AWS CloudShell y conéctate a ellos mediante el siguiente comando. Asegúrese de actualizar *us-east-1* con su propia región.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
La salida de ese comando debería tener este aspecto.
```
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. Para poder escribir datos en su tabla Amazon Keyspaces con cqlsh, antes debe establecer la coherencia de escritura de la sesión actual de cqlsh en `LOCAL_QUORUM`. Para obtener más información sobre los niveles de coherencia admitidos, consulte [Niveles de coherencia de escritura](consistency.md#WriteConsistency). Tenga en cuenta que este paso no es necesario si utiliza el editor CQL en la Consola de administración de AWS.
```
CONSISTENCY LOCAL_QUORUM;
```
1. Para insertar un único registro, ejecute el siguiente comando en el editor CQL.
```
INSERT INTO catalog.book_awards (award, year, category, rank, author, book_title, publisher)
VALUES ('Wolf', 2023, 'Fiction',3,'Shirley Rodriguez','Mountain', 'AnyPublisher') ;
```
1. Verifique que los datos se hayan añadido correctamente a su tabla; para ello, ejecute el siguiente comando.
```
SELECT * FROM catalog.book_awards;
```
La salida de la sentencia debería tener el siguiente aspecto.
```
year | award | category | rank | author | book_title | publisher
------+-------+----------+------+-------------------+------------+--------------
2023 | Wolf | Fiction | 3 | Shirley Rodriguez | Mountain | AnyPublisher
(1 rows)
```
**Para insertar varios registros desde un archivo con cqlsh**
1. Descargue el archivo CSV de ejemplo (`keyspaces_sample_table.csv`), contenido en el archivo comprimido [samplemigration.zip](samples/samplemigration.zip). Descomprima el archivo y tome nota de la ruta a `keyspaces_sample_table.csv`.
![\[Captura de pantalla de un archivo CSV que muestra el resultado de la tabla después de importar el archivo csv.\]](http://docs.aws.amazon.com/es_es/keyspaces/latest/devguide/images/keyspaces-awards.png)
1. Abre AWS CloudShell Consola de administración de AWS y conéctate a Amazon Keyspaces mediante el siguiente comando. Asegúrese de actualizar *us-east-1* con su propia región.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. En la línea de comandos de `cqlsh` (`cqlsh>`), especifique un espacio de claves.
```
USE catalog ;
```
1. Establezca la coherencia de escritura en `LOCAL_QUORUM`. Para obtener más información sobre los niveles de coherencia admitidos, consulte [Niveles de coherencia de escritura](consistency.md#WriteConsistency).
```
CONSISTENCY LOCAL_QUORUM;
```
1. AWS CloudShell Selecciona **Acciones** en la parte superior derecha de la pantalla y, a continuación, selecciona **Cargar archivo** para cargar el archivo csv descargado anteriormente. Tome nota de la ruta al archivo.
1. En la línea de comandos de espacio de claves (`cqlsh:catalog>`), ejecute la siguiente instrucción.
```
COPY book_awards (award, year, category, rank, author, book_title, publisher) FROM '/home/cloudshell-user/keyspaces_sample_table.csv' WITH header=TRUE ;
```
La salida de la instrucción debe ser similar a esta.
```
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. Verifique que los datos se hayan añadido correctamente a su tabla; para ello, ejecute la siguiente consulta.
```
SELECT * FROM book_awards ;
```
Debería ver la siguiente salida.
```
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)
```
Para obtener más información sobre cómo usar `cqlsh COPY` para cargar datos desde archivos csv a una tabla de Amazon Keyspaces, consulte [Tutorial: Carga de datos en Amazon Keyspaces utilizando cqlsh](bulk-upload.md).
# Lectura de los datos de una tabla con la instrucción CQL `SELECT` en Amazon Keyspaces
En la sección [Inserción y carga de datos en una tabla de Amazon Keyspaces](getting-started.dml.create.md), utilizó la instrucción `SELECT` para verificar que ha añadido correctamente los datos a su tabla. En esta sección, usted restringe el uso de `SELECT` para mostrar columnas específicas y solo las filas que cumplan criterios específicos.
La forma general de la instrucción `SELECT` es la siguiente.
```
SELECT column_list FROM table_name [WHERE condition [ALLOW FILTERING]] ;
```
**Topics**
+ [
## Selección de todos los datos de la tabla
](#getting-started.dml.read.all)
+ [
## Selección de un subconjunto de columnas
](#getting-started.dml.read.columns)
+ [
## Selección de un subconjunto de filas
](#getting-started.dml.read.rows)
## Selección de todos los datos de la tabla
La forma más sencilla de la instrucción `SELECT` devuelve todos los datos de su tabla.
**importante**
En un entorno de producción, no suele ser una práctica recomendada ejecutar este comando, dado que devuelve todos los datos de la tabla.
**Para seleccionar todos los datos de su tabla**
1. Abre Amazon Keyspaces AWS CloudShell y conéctate a ellos mediante el siguiente comando. Asegúrese de actualizar *us-east-1* con su propia región.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Ejecute la siguiente consulta.
```
SELECT * FROM catalog.book_awards ;
```
El uso del carácter comodín (`*`) para `column_list` selecciona todas las columnas. La salida de la instrucción tiene un aspecto semejante al del siguiente ejemplo.
```
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
```
## Selección de un subconjunto de columnas
**Para consultar un subconjunto de columnas**
1. Abre Amazon Keyspaces AWS CloudShell y conéctate a ellos mediante el siguiente comando. Asegúrese de actualizar *us-east-1* con su propia región.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Para recuperar solo las columnas `award`, `category` y `year`, ejecute la siguiente consulta.
```
SELECT award, category, year FROM catalog.book_awards ;
```
La salida contiene solo las columnas especificadas en el orden indicado en la instrucción `SELECT`.
```
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
```
## Selección de un subconjunto de filas
Al consultar un gran conjunto de datos, es posible que solo desee registros que cumplan determinados criterios. Para ello, puede añadir una cláusula `WHERE` al final de nuestra instrucción `SELECT`.
**Para consultar un subconjunto de filas**
1. Abre Amazon Keyspaces AWS CloudShell y conéctate a ellos mediante el siguiente comando. Asegúrese de actualizar *us-east-1* con su propia región.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Para recuperar solo los registros de los premios de un año determinado, ejecute la siguiente consulta.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Wolf' ;
```
La instrucción `SELECT` anterior devuelve la siguiente salida.
```
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
```
### Comprensión de la cláusula `WHERE`
La cláusula `WHERE` se utiliza para filtrar los datos y devolver solo los que cumplan los criterios especificados. Los criterios especificados pueden ser una condición simple o una condición compuesta.
**Uso de condiciones en una cláusula `WHERE`**
+ Una condición simple: una única columna.
```
WHERE column_name=value
```
Puede utilizar una condición simple en una cláusula `WHERE` si se cumple alguna de las siguientes condiciones:
+ La columna es la única columna de la clave de partición de la tabla.
+ Ha añadido `ALLOW FILTERING` después de la condición en la cláusula `WHERE`.
Tenga en cuenta que el uso de `ALLOW FILTERING` puede dar lugar a un rendimiento incoherente, sobre todo con tablas de gran tamaño y con varias particiones.
+ Una condición compuesta: múltiples condiciones simples conectadas por `AND`.
```
WHERE column_name1=value1 AND column_name2=value2 AND column_name3=value3...
```
Puede utilizar condiciones compuestas en una cláusula `WHERE` si se cumple alguna de las siguientes condiciones:
+ Las columnas que puede usar en la cláusula `WHERE` deben incluir todas o un subconjunto de las columnas de la clave de partición de la tabla. Si desea utilizar solo un subconjunto de las columnas de la cláusula `WHERE`, debe incluir un conjunto contiguo de columnas de clave de partición de izquierda a derecha, empezando por la primera columna de la clave de partición. Por ejemplo, si las columnas de la clave de partición son `year`, `month` y `award`, puede usar las siguientes columnas en la cláusula `WHERE`:
+ `year`
+ `year` Y `month`
+ `year` Y `month` Y `award`
+ Añada `ALLOW FILTERING` después de la condición compuesta en la cláusula `WHERE`, como en el siguiente ejemplo.
```
SELECT * FROM my_table WHERE col1=5 AND col2='Bob' ALLOW FILTERING ;
```
Tenga en cuenta que el uso de `ALLOW FILTERING` puede dar lugar a un rendimiento incoherente, sobre todo con tablas de gran tamaño y con varias particiones.
### Pruébelo
Cree sus propias consultas CQL para obtener los siguientes resultados de su tabla `book_awards`:
+ Busque los ganadores de los premios Wolf de 2020 y haga que se muestren los títulos y autores de los libros, ordenados por su puesto en la clasificación.
+ Haga que se muestren los ganadores del primer puesto de todos los premios de 2020 y que aparezcan los títulos de los libros y los nombres de los premios.
# Actualización de datos en una tabla de Amazon Keyspaces con CQL
Para actualizar los datos de su tabla `book_awards`, utilice la instrucción `UPDATE`.
La forma general de la instrucción `UPDATE` es la siguiente.
```
UPDATE table_name SET column_name=new_value WHERE primary_key=value ;
```
**sugerencia**
Puede actualizar múltiples columnas utilizando una lista separada por comas de `column_names` y valores, como en el siguiente ejemplo.
```
UPDATE my_table SET col1='new_value_1', col2='new_value2' WHERE col3='1' ;
```
Si la clave principal se compone de múltiples columnas, todas las columnas de la clave principal y sus valores deben incluirse en la cláusula `WHERE`.
No puede actualizar ninguna columna de la clave principal porque eso cambiaría la clave principal del registro.
**Para actualizar una única celda**
Con la tabla `book_awards`, cambie el nombre de una editorial del ganador de los premios Wolf de no ficción en 2020.
```
UPDATE book_awards SET publisher='new Books' WHERE year = 2020 AND award='Wolf' AND category='Non-Fiction' AND rank=1;
```
Compruebe que la editorial sea ahora `new Books`.
```
SELECT * FROM book_awards WHERE year = 2020 AND award='Wolf' AND category='Non-Fiction' AND rank=1;
```
La instrucción debería devolver la siguiente salida.
```
year | award | category | rank | author | book_title | publisher
------+-------+-------------+------+-------------+------------------+-----------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | new Books
```
## Pruébelo
**Avanzado:** el ganador del “Premio Kwezi Manu” de ficción de 2020 ha cambiado de nombre. Actualice este registro para cambiar el nombre a `'Akua Mansa-House'`.
# Eliminación de los datos de una tabla mediante la sentencia CQL `DELETE`
Para eliminar datos en su tabla `book_awards`, utilice la instrucción `DELETE`.
Puede eliminar datos de una fila o de una partición. Tenga cuidado al eliminar datos, dado que la eliminación es irreversible.
Al eliminar una o todas las filas de una tabla, no elimina la tabla. Por tanto, puede volver a llenarla con datos. Al eliminar una tabla, elimina la tabla y todos los datos que contiene. Para volver a utilizar la tabla, debe volver a crearla y añadirle datos. Al eliminar un espacio de claves, elimina el espacio de claves y todas las tablas que contiene. Para volver a utilizar el espacio de claves y las tablas, debe volver a crearlos y rellenarlos con datos. Puede utilizar la recuperación de Amazon Keyspaces Point-in-time (PITR) para restaurar las tablas eliminadas; para obtener más información, consulte. [Backup y restauración de datos con point-in-time recuperación para Amazon Keyspaces](PointInTimeRecovery.md) Para obtener información sobre cómo restaurar una tabla eliminada con la PITR activada, consulte [Restauración de una tabla eliminada con la PITR de Amazon Keyspaces](restoredeleted.md).
## Eliminación de celdas
Al eliminar una columna de una fila se eliminan los datos de la celda especificada. Al mostrar esa columna mediante una `SELECT` sentencia, los datos se muestran como*null*, aunque no se almacene un valor nulo en esa ubicación.
La sintaxis general para eliminar una o varias columnas en concreto es la siguiente.
```
DELETE column_name1[, column_name2...] FROM table_name WHERE condition ;
```
En la tabla `book_awards`, puede ver que el título del libro que ganó el primer premio “Richard Roe” de 2020 es “Long Summer”. Imagine que se ha retirado del mercado este título y necesita eliminar los datos de esta celda.
**Para eliminar una celda en concreto**
1. Abre Amazon Keyspaces AWS CloudShell y conéctate a ellos mediante el siguiente comando. Asegúrese de actualizar *us-east-1* con su propia región.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Ejecute la siguiente consulta `DELETE`.
```
DELETE book_title FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
1. Compruebe que la solicitud de eliminación se haya realizado como se esperaba.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
La salida de esta instrucción tiene el siguiente aspecto.
```
year | award | category | rank | author | book_title | publisher
------+-------------+----------+------+-------------------+------------+---------------
2020 | Richard Roe | Fiction | 1 | Alejandro Rosalez | null | SomePublisher
```
## Eliminación de filas
Podría darse el caso de que necesite eliminar una fila entera, por ejemplo, para cumplir con una solicitud de eliminación de datos. La sintaxis general para eliminar una fila es la siguiente.
```
DELETE FROM table_name WHERE condition ;
```
**Para eliminar una fila**
1. Abre Amazon Keyspaces AWS CloudShell y conéctate a ellos mediante el siguiente comando. Asegúrese de actualizar *us-east-1* con su propia región.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Ejecute la siguiente consulta `DELETE`.
```
DELETE FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
1. Compruebe que la eliminación se haya realizado como se esperaba.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
El resultado de esta instrucción tiene este aspecto después de eliminar la fila.
```
year | award | category | rank | author | book_title | publisher
------+-------+----------+------+--------+------------+-----------
(0 rows)
```
Puede eliminar automáticamente los datos caducados de la tabla con el periodo de vida de Amazon Keyspaces. Para obtener más información, consulte [Caducidad de datos con período de vida (TTL) para Amazon Keyspaces (para Apache Cassandra)](TTL.md).
# Eliminación de una tabla en Amazon Keyspaces
Para evitar que le cobren por tablas y datos que no necesite, elimine todas las tablas que no utilice. Al eliminar una tabla, la tabla y sus datos se eliminan y deja de acumular cargos por ellos. Sin embargo, el espacio de claves permanece. Al eliminar un espacio de claves, el espacio de claves y todas sus tablas se eliminan y deja de acumular cargos por ellos.
Puede eliminar una tabla utilizando la consola, CQL o la AWS CLI. Al eliminar una tabla, se eliminan la tabla y todos sus datos.
## Uso de la consola
El siguiente procedimiento elimina una tabla y todos sus datos utilizando la Consola de administración de AWS.
**Para eliminar una tabla con la consola**
1. [Inicia sesión en la Consola de administración de AWS consola de Amazon Keyspaces y ábrela desde casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. En el panel de navegación, elija **Tablas**.
1. Elija la casilla situada a la izquierda del nombre de cada tabla que desee eliminar.
1. Elija **Eliminar**.
1. En la pantalla **Eliminar tabla**, introduzca **Delete** en el cuadro. A continuación, elija **Eliminar tabla**.
1. Para verificar la eliminación de la tabla, elija **Tablas** en el panel de navegación y confirme que la tabla `book_awards` ya no aparezca en la lista.
## Uso de CQL
El siguiente procedimiento elimina una tabla y todos sus datos utilizando CQL.
**Eliminación de una tabla con CQL**
1. Abre Amazon Keyspaces AWS CloudShell y conéctate a ellos mediante el siguiente comando. Asegúrese de actualizar *us-east-1* con su propia región.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Elimine la tabla introduciendo la siguiente instrucción.
```
DROP TABLE IF EXISTS catalog.book_awards ;
```
1. Verifique que se haya eliminado su tabla.
```
SELECT * FROM system_schema.tables WHERE keyspace_name = 'catalog' ;
```
La salida debería tener este aspecto. Tenga en cuenta que esto puede llevar algún tiempo, así que vuelva a ejecutar la instrucción después de un minuto si no ve este resultado.
```
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)
```
## Usando el AWS CLI
El siguiente procedimiento elimina una tabla y todos sus datos utilizando la AWS CLI.
**Para eliminar una tabla mediante el AWS CLI**
1. Abra CloudShell
1. Elimine la tabla con la siguiente instrucción.
```
aws keyspaces delete-table --keyspace-name 'catalog' --table-name 'book_awards'
```
1. Para comprobar que la tabla se ha eliminado, puede enumerar todas las tablas en un espacio de claves.
```
aws keyspaces list-tables --keyspace-name 'catalog'
```
Debería ver la siguiente salida. Tenga en cuenta que esta operación asíncrona puede llevar algún tiempo. Espere un tiempo y vuelva a ejecutar el comando para confirmar que la tabla se haya eliminado.
```
{
"tables": []
}
```
# Eliminación de un espacio de claves en Amazon Keyspaces
Para evitar que se le cobren cargos por espacios de claves, elimine todos aquellos que no utilice. Al eliminar un espacio de claves, el espacio de claves y todas sus tablas se eliminan y deja de acumular cargos por ellos.
Puede eliminar un espacio de claves con la consola, CQL o la AWS CLI.
## Uso de la consola
El siguiente procedimiento elimina un espacio de claves y todas sus tablas y datos utilizando la consola.
**Para eliminar un espacio de claves con la consola**
1. [Inicia sesión en la Consola de administración de AWS consola de Amazon Keyspaces y ábrela desde casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. En el panel de navegación, elija **Espacios de claves**.
1. Elija la casilla situada a la izquierda del nombre de cada espacio de claves que desee eliminar.
1. Elija **Eliminar**.
1. En la pantalla **Eliminar espacio de claves**, introduzca **Delete** en el cuadro. A continuación, elija **Eliminar espacio de claves**.
1. Para verificar la eliminación del espacio de claves `catalog`, elija **Espacios de claves** en el panel de navegación y confirme que ya no aparezca en la lista. Dado que ha eliminado su espacio de claves, la tabla `book_awards` en **Tablas** tampoco debería aparecer en la lista.
## Uso de CQL
El siguiente procedimiento elimina un espacio de claves y todas sus tablas y datos utilizando CQL.
**Para eliminar un espacio de claves con CQL**
1. Abre Amazon Keyspaces AWS CloudShell y conéctate a ellos mediante el siguiente comando. Asegúrese de actualizar *us-east-1* con su propia región.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Elimine el espacio de claves introduciendo la siguiente instrucción.
```
DROP KEYSPACE IF EXISTS catalog ;
```
1. Compruebe que el espacio de claves haya sido eliminado.
```
SELECT * from system_schema.keyspaces ;
```
El espacio de claves no debería aparecer en la lista. Tenga en cuenta que, dado que se trata de una operación asíncrona, puede haber un retraso hasta que se elimine el espacio de claves. Una vez eliminado el espacio de claves, el resultado de la instrucción debería tener este aspecto.
```
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)
```
## Usando el AWS CLI
El siguiente procedimiento elimina un espacio de claves y todas sus tablas y datos utilizando la AWS CLI.
**Para eliminar un espacio de claves mediante el AWS CLI**
1. Abra AWS CloudShell
1. Elimine el espacio de claves introduciendo la siguiente instrucción.
```
aws keyspaces delete-keyspace --keyspace-name 'catalog'
```
1. Compruebe que el espacio de claves haya sido eliminado.
```
aws keyspaces list-keyspaces
```
El resultado de esta sentencia debería tener un aspecto similar al siguiente y mostrar únicamente los espacios de claves del sistema. Tenga en cuenta que, dado que se trata de una operación asíncrona, puede haber un retraso hasta que se elimine el espacio de claves.
```
{
"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"
}
]
}
```