Crie uma nova tabela do Amazon Keyspaces com maior taxa de transferência de calor

Como criar uma nova tabela com configurações de taxa de transferência a quente

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Keyspaces em casahttps://console.aws.amazon.com/keyspaces/.

2. No painel de navegação, selecione Tabelas e Criar tabela.

3. Na página Criar tabela, na seção Detalhes da tabela, selecione um espaço de chaves e forneça um nome para a nova tabela.

4. Na seção Colunas, crie o esquema para sua tabela.

5. Na seção Chave primária, defina a chave primária da tabela e selecione colunas de clustering opcionais.

6. Na seção Configurações da tabela, selecione Personalizar configurações.

7. Continue com as configurações de capacidade de leitura/gravação.

8. Para o modo Capacidade, você pode escolher entre Sob demanda ou Provisionado.

9. Na seção Pré-aquecimento para tabelas, você pode aumentar os valores de unidades de leitura por segundo e unidades de gravação por segundo conforme necessário para preparar sua tabela para lidar com eventos de pico planejados.

   Os valores de taxa de transferência quente que o Amazon Keyspaces ajusta com base no seu uso sob demanda ou na capacidade provisionada estão disponíveis por padrão para todas as tabelas sem custos adicionais. Observe que, se você aumentar manualmente os valores padrão de taxa de transferência de aquecimento para pré-aquecer a tabela para eventos de pico de tráfego, cobranças adicionais serão aplicadas.

10. Configure outros recursos opcionais da tabela conforme necessário. Em seguida, escolha Criar tabela.

• Crie uma tabela com taxa de transferência quente usando um dos seguintes métodos:

  • Para o modo provisionado, crie uma tabela e especifique a capacidade de pico esperada para leituras e gravações usando a seguinte sintaxe 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 o modo sob demanda, crie uma tabela e especifique a capacidade de pico esperada para leituras e gravações usando a seguinte sintaxe 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 as configurações de capacidade da tabela, consulteVeja a taxa de transferência quente de uma tabela do Amazon Keyspaces.

1. Crie uma tabela com taxa de transferência quente usando um dos métodos a seguir usando o AWS CLI

   • Crie uma nova tabela no modo provisionado e especifique os valores de capacidade de pico esperados para leituras e gravações para ela. A instrução a seguir é um exemplo disso.

     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

   • Crie uma nova tabela no modo sob demanda e especifique os valores de capacidade de pico esperados para leituras e gravações para a nova tabela. A instrução a seguir é um exemplo disso.

     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. A saída do comando retorna o ARN da tabela, conforme mostrado no exemplo a seguir.

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

   Para confirmar as configurações de capacidade da tabela, consulteVeja a taxa de transferência quente de uma tabela do Amazon Keyspaces.

Crie uma nova tabela usando o SDK for Java.

• Crie uma nova tabela no modo provisionado e especifique os valores de capacidade de pico esperados para leituras e gravações para ela. O exemplo de código a seguir é um exemplo disso.

  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());
      }
  }