Créez une nouvelle table Amazon Keyspaces avec un débit de chauffage plus élevé

Comment créer une nouvelle table avec des paramètres de débit à chaud

1. Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.

2. Dans le panneau de navigation, choisissez Tables, puis Create table (Créer une table).

3. Sur la page Créer une table, dans la section Détails de la table, sélectionnez un espace de touche et attribuez un nom à la nouvelle table.

4. Dans la section Colonnes, créez le schéma de votre table.

5. Dans la section Clé primaire, définissez la clé primaire de la table et sélectionnez les colonnes de clustering facultatives.

6. Dans la section Paramètres du tableau, choisissez Personnaliser les paramètres.

7. Continuez jusqu'à Paramètres de capacité en lecture/écriture.

8. Pour le mode Capacité, vous pouvez choisir entre On-Demand ou Provisioned.

9. Dans la section Préchauffage des tables, vous pouvez augmenter les valeurs des unités de lecture par seconde et des unités d'écriture par seconde selon les besoins pour préparer votre table à gérer les pics planifiés.

   Les valeurs de débit à chaud qu'Amazon Keyspaces ajuste en fonction de votre utilisation à la demande ou de la capacité allouée sont disponibles par défaut pour toutes les tables sans frais supplémentaires. Notez que si vous augmentez manuellement les valeurs de débit de chauffage par défaut pour préchauffer la table en cas de pic de trafic, des frais supplémentaires s'appliquent.

10. Configurez les autres fonctionnalités facultatives du tableau selon vos besoins. Choisissez ensuite Créer une table.

• Créez une table avec un débit à chaud à l'aide de l'une des méthodes suivantes :

  • Pour le mode provisionné, créez une table et spécifiez la capacité maximale attendue pour les lectures et les écritures à l'aide de la syntaxe CQL suivante :

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

  • Pour le mode à la demande, créez une table et spécifiez la capacité maximale attendue pour les lectures et les écritures à l'aide de la syntaxe CQL suivante :

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

  Pour confirmer les paramètres de capacité du tableau, voirAfficher le débit à chaud d'une table Amazon Keyspaces.

1. Créez une table avec un débit à chaud en utilisant l'une des méthodes suivantes à l'aide du AWS CLI

   • Créez une nouvelle table en mode provisionné et spécifiez les valeurs de capacité maximale attendues pour les lectures et les écritures pour la nouvelle table. La déclaration suivante en est un exemple.

     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

   • Créez une nouvelle table en mode à la demande et spécifiez les valeurs de capacité maximale attendues pour les lectures et les écritures pour la nouvelle table. La déclaration suivante en est un exemple.

     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. La sortie de la commande renvoie l'ARN de la table, comme indiqué dans l'exemple suivant.

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

   Pour confirmer les paramètres de capacité du tableau, voirAfficher le débit à chaud d'une table Amazon Keyspaces.

Créez une nouvelle table à l'aide du SDK for Java.

• Créez une nouvelle table en mode provisionné et spécifiez les valeurs de capacité maximale attendues pour les lectures et les écritures pour la nouvelle table. L'exemple de code suivant en est un exemple.

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