

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.

# Creación de un espacio de claves en Amazon Keyspaces
<a name="getting-started.tables"></a>

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
<a name="getting-started.tables.con"></a>

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
<a name="getting-started.tables.cql"></a>

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
<a name="getting-started.tables.cli"></a>

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