Crea una nuova tabella Amazon Keyspaces con un throughput caldo più elevato

Come creare una nuova tabella con impostazioni di throughput caldo

1. Accedi a e apri Console di gestione AWS la console Amazon Keyspaces a casahttps://console.aws.amazon.com/keyspaces/.

2. Nel pannello di navigazione, scegli Tabelle, quindi seleziona Crea tabella.

3. Nella pagina Crea tabella, nella sezione Dettagli della tabella, seleziona un keyspace e fornisci un nome per la nuova tabella.

4. Nella sezione Colonne, crea lo schema per la tua tabella.

5. Nella sezione Chiave primaria, definisci la chiave primaria della tabella e seleziona le colonne di clustering opzionali.

6. Nella sezione Impostazioni tabella, scegli Personalizza impostazioni.

7. Continua con le impostazioni della capacità di lettura/scrittura.

8. Per la modalità Capacity, è possibile scegliere On-demand o Provisioned.

9. Nella sezione Preriscaldamento per le tabelle, è possibile aumentare i valori delle unità di lettura al secondo e delle unità di scrittura al secondo, in base alle esigenze, per preparare la tabella alla gestione degli eventi di picco pianificati.

   I valori di throughput a caldo che Amazon Keyspaces regola in base all'utilizzo su richiesta o alla capacità fornita sono disponibili per impostazione predefinita per tutte le tabelle senza costi aggiuntivi. Tieni presente che se aumenti manualmente i valori di throughput caldo predefiniti per preriscaldare la tabella in caso di picchi di traffico, verranno applicati costi aggiuntivi.

10. Configura altre funzionalità opzionali della tabella in base alle esigenze. Quindi scegli Crea tabella.

• Crea una tabella con una produttività a caldo utilizzando uno dei seguenti metodi:

  • Per la modalità provisioning, create una tabella e specificate la capacità di picco prevista per le letture e le scritture utilizzando la seguente sintassi 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  
         }
    };

  • Per la modalità su richiesta, create una tabella e specificate la capacità di picco prevista per le letture e le scritture utilizzando la seguente sintassi 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  
         }
    };

  Per confermare le impostazioni di capacità della tabella, vedere. Visualizza la velocità effettiva effettiva di una tabella Amazon Keyspaces

1. Create una tabella con una produttività a caldo utilizzando uno dei seguenti metodi utilizzando AWS CLI

   • Create una nuova tabella in modalità provisioning e specificate i valori di capacità di picco previsti per le letture e le scritture per la nuova tabella. La seguente dichiarazione ne è un esempio.

     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

   • Crea una nuova tabella in modalità su richiesta e specifica i valori di capacità di picco previsti per le letture e le scritture per la nuova tabella. La seguente dichiarazione ne è un esempio.

     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. L'output del comando restituisce l'ARN della tabella come illustrato nell'esempio seguente.

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

   Per confermare le impostazioni di capacità della tabella, vedereVisualizza la velocità effettiva effettiva di una tabella Amazon Keyspaces.

Crea una nuova tabella utilizzando l'SDK for Java.

• Crea una nuova tabella in modalità provisioning e specifica i valori di capacità di picco previsti per le letture e le scritture per la nuova tabella. Il seguente esempio di codice ne è un esempio.

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