Cree una nueva tabla de Amazon Keyspaces con un rendimiento cálido superior

¿Cómo crear una tabla nueva con una configuración de rendimiento cálido

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

2. En el panel de navegación, elija Tablas y, a continuación, seleccione Crear tabla.

3. En la página Crear tabla, en la sección Detalles de la tabla, seleccione un espacio de claves y proporcione un nombre para la nueva tabla.

4. En la sección Columnas, cree el esquema para la tabla.

5. En la sección Clave principal, defina la clave principal de la tabla y seleccione las columnas de agrupación en clústeres opcionales.

6. En la sección Configuración de la tabla, elija Personalizar configuración.

7. Continúe en Configuración de capacidad de lectura/escritura.

8. Para el modo de capacidad, puede elegir entre Bajo demanda o Aprovisionado.

9. En la sección Precalentamiento de las tablas, puede aumentar los valores de las unidades de lectura por segundo y las unidades de escritura por segundo según sea necesario para preparar la mesa para gestionar los picos de actividad planificados.

   Los valores de rendimiento cálido que Amazon Keyspaces ajusta en función del uso bajo demanda o de la capacidad aprovisionada están disponibles de forma predeterminada para todas las tablas sin cargos adicionales. Tenga en cuenta que si aumenta manualmente los valores de rendimiento en caliente predeterminados para precalentar la tabla en caso de picos de tráfico, se aplicarán cargos adicionales.

10. Configure otras funciones opcionales de la tabla según sea necesario. A continuación, selecciona Crear tabla.

• Cree una tabla con un rendimiento óptimo mediante uno de los siguientes métodos:

  • Para el modo aprovisionado, cree una tabla y especifique la capacidad máxima esperada de lectura y escritura mediante la siguiente sintaxis CQL:

    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))
    WITH CUSTOM_PROPERTIES = {  
        'capacity_mode': {
           'throughput_mode': 'PROVISIONED',
           'read_capacity_units': 20000,
           'write_capacity_units': 10000
         },
        'warm_throughput': {  
            'read_units_per_second': 40000,  
            'write_units_per_second': 20000  
         }
    };

  • Para el modo bajo demanda, cree una tabla y especifique la capacidad máxima esperada de lectura y escritura mediante la siguiente sintaxis de CQL:

    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))
    WITH CUSTOM_PROPERTIES = {  
        'capacity_mode': {
           'throughput_mode': 'PAY_PER_REQUEST'
         },
        'warm_throughput': {  
            'read_units_per_second': 40000,  
            'write_units_per_second': 20000  
         }
    };

  Para confirmar la configuración de capacidad de la tabla, consulteVea el rendimiento cálido de una tabla de Amazon Keyspaces.

1. Cree una tabla con un rendimiento óptimo mediante uno de los siguientes métodos mediante el AWS CLI

   • Cree una tabla nueva en el modo aprovisionado y especifique los valores de la capacidad máxima de lectura y escritura prevista para la nueva tabla. La siguiente instrucción es un ejemplo de ello.

     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=book_title,type=text},{name=author,type=text},{name=publisher,type=text}],partitionKeys=[{name=year},{name=award}],clusteringKeys=[{name=category,orderBy=ASC},{name=rank,orderBy=ASC}]' \
     --capacity-specification throughputMode=PROVISIONED,readCapacityUnits=20000,writeCapacityUnits=10000 \
     --warm-throughput-specification readUnitsPerSecond=40000,writeUnitsPerSecond=20000

   • Cree una tabla nueva en modo bajo demanda y especifique los valores de capacidad máxima esperados para las lecturas y escrituras de la nueva tabla. La siguiente instrucción es un ejemplo de ello.

     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=book_title,type=text},{name=author,type=text},{name=publisher,type=text}],partitionKeys=[{name=year},{name=award}],clusteringKeys=[{name=category,orderBy=ASC},{name=rank,orderBy=ASC}]' \
     --warmThroughputSpecification readUnitsPerSecond=40000,writeUnitsPerSecond=20000

2. El resultado del comando devuelve el ARN de la tabla, como se muestra en el siguiente ejemplo.

   {
       "resourceArn": "arn:aws::cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards>"
   }

   Para confirmar la configuración de capacidad de la tabla, consulteVea el rendimiento cálido de una tabla de Amazon Keyspaces.

Cree una tabla nueva con el SDK for Java.

• Cree una tabla nueva en el modo aprovisionado y especifique los valores de la capacidad máxima de lectura y escritura prevista para la nueva tabla. El siguiente ejemplo de código es un ejemplo de ello.

  import software.amazon.awssdk.services.keyspaces.KeyspacesClient;
  import software.amazon.awssdk.services.keyspaces.model.*;
  
  public class PreWarmingExample {
      public static void main(String[] args) {
          KeyspacesClient keyspacesClient = KeyspacesClient.builder().build();
  
          // Define schema
          List<ColumnDefinition> columns = Arrays.asList(
              ColumnDefinition.builder().name("year").type("int").build(),
              ColumnDefinition.builder().name("award").type("text").build(),
              ColumnDefinition.builder().name("rank").type("int").build(),
              ColumnDefinition.builder().name("category").type("text").build(),
              ColumnDefinition.builder().name("book_title").type("text").build(),
              ColumnDefinition.builder().name("author").type("text").build(),
              ColumnDefinition.builder().name("publisher").type("text").build()
          );
          
          List<PartitionKey> partitionKeys = Arrays.asList(
              PartitionKey.builder().name("year").build(),
              PartitionKey.builder().name("award").build()
          );
          
          List<ClusteringKey> clusteringKeys = Arrays.asList(
              ClusteringKey.builder().name("category").orderBy("ASC").build(),
              ClusteringKey.builder().name("rank").orderBy("ASC").build()
          );
          
          SchemaDefinition schema = SchemaDefinition.builder()
              .allColumns(columns)
              .partitionKeys(partitionKeys)
              .clusteringKeys(clusteringKeys)
              .build();
  
          // Define capacity specification
          CapacitySpecification capacitySpec = CapacitySpecification.builder()
              .throughputMode(ThroughputMode.PROVISIONED)
              .readCapacityUnits(20000)
              .writeCapacityUnits(10000)
              .build();
              
          // Define warm throughput specification
          WarmThroughputSpecification warmThroughput = WarmThroughputSpecification.builder()
              .readUnitsPerSecond(40000L)
              .writeUnitsPerSecond(20000L)
              .build();
  
          // Create table with PreWarming
          CreateTableRequest request = CreateTableRequest.builder()
              .keyspaceName("catalog")
              .tableName("book_awards")
              .schemaDefinition(schema)
              .capacitySpecification(capacitySpec)
              .warmThroughputSpecification(warmThroughput)
              .build();
              
          CreateTableResponse response = keyspacesClient.createTable(request);
          System.out.println("Table created with ARN: " + response.resourceArn());
      }
  }