Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Gestione delle risorse serverless in Amazon Keyspaces (per Apache Cassandra)
Amazon Keyspaces (per Apache Cassandra) è serverless. Invece di distribuire, gestire e mantenere le risorse di storage e di calcolo per il carico di lavoro attraverso i nodi di un cluster, Amazon Keyspaces alloca le risorse di storage e read/write di throughput direttamente alle tabelle.
Amazon Keyspaces fornisce automaticamente lo storage in base ai dati archiviati nelle tabelle. Aumenta e riduce lo storage man mano che scrivi, aggiorni ed elimini i dati e paghi solo per lo storage che utilizzi. I dati vengono replicati su più [zone di disponibilità](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/) per un'elevata disponibilità. Amazon Keyspaces monitora continuamente le dimensioni delle tabelle per determinare i costi di storage. Per ulteriori informazioni su come Amazon Keyspaces calcola la dimensione fatturabile dei dati, consulta. [Stima della dimensione delle righe in Amazon Keyspaces](calculating-row-size.md)
Questo capitolo tratta gli aspetti chiave della gestione delle risorse in Amazon Keyspaces.
+ **Stima della dimensione delle righe**: per stimare la dimensione codificata delle righe in Amazon Keyspaces, considera fattori come i metadati delle chiavi di partizione, i metadati delle colonne di clustering, gli identificatori di colonna, i tipi di dati e i metadati delle righe. Questa dimensione di riga codificata viene utilizzata per la fatturazione, la gestione delle quote e la pianificazione della capacità di throughput assegnata.
+ **Stima del consumo di capacità**: questa sezione contiene esempi di come stimare il consumo di capacità di lettura e scrittura per scenari comuni come query con intervallo, query con limiti, scansioni di tabelle, transazioni leggere, colonne statiche e tabelle multiregionali. Puoi utilizzare Amazon CloudWatch per monitorare l'utilizzo effettivo della capacità. Per ulteriori informazioni sul monitoraggio con CloudWatch, consulta[Monitoraggio di Amazon Keyspaces con Amazon CloudWatch](monitoring-cloudwatch.md).
+ **Configurazione delle modalità di read/write capacità**: è possibile scegliere tra due modalità di capacità per l'elaborazione di letture e scritture sulle tabelle:
+ **Modalità on-demand (impostazione predefinita)**: paga per richiesta per la velocità effettiva di lettura e scrittura. Amazon Keyspaces può scalare istantaneamente la capacità fino a qualsiasi livello di traffico raggiunto in precedenza.
+ **Modalità di provisioning**: specifica in anticipo il numero richiesto di unità con capacità di lettura e scrittura. Questa modalità aiuta a mantenere prestazioni di throughput prevedibili.
+ **Gestisci la capacità di throughput con la scalabilità automatica**: per le tabelle con provisioning, è possibile abilitare la scalabilità automatica per regolare automaticamente la capacità di throughput in base al traffico effettivo delle applicazioni. Amazon Keyspaces utilizza il tracciamento del target per aumentare o diminuire la capacità fornita, mantenendo l'utilizzo all'obiettivo specificato.
+ **Usa la capacità di burst in modo efficace**: Amazon Keyspaces fornisce capacità di burst riservando una parte del throughput inutilizzato per gestire i picchi di traffico. Questa flessibilità consente occasionali picchi di attività superiori al throughput previsto.
Per risolvere gli errori di capacità, vedere. [Errori di capacità serverless](troubleshooting.serverless.md#troubleshooting-serverless)
**Topics**
+ [Stima della dimensione delle righe in Amazon Keyspaces](calculating-row-size.md)
+ [Stima del consumo di capacità per la velocità effettiva di lettura e scrittura in Amazon Keyspaces](capacity-examples.md)
+ [Configura le modalità di read/write capacità in Amazon Keyspaces](ReadWriteCapacityMode.md)
+ [Gestisci automaticamente la capacità di throughput con la scalabilità automatica di Amazon Keyspaces](autoscaling.md)
+ [Usa la capacità burst in modo efficace in Amazon Keyspaces](throughput-bursting.md)
# Stima della dimensione delle righe in Amazon Keyspaces
Amazon Keyspaces fornisce uno storage completamente gestito che offre prestazioni di lettura e scrittura a una cifra di millisecondi e archivia i dati in modo duraturo su più zone di disponibilità. AWS Amazon Keyspaces allega i metadati a tutte le righe e le colonne chiave primarie per supportare un accesso efficiente ai dati e un'elevata disponibilità.
Questo argomento fornisce dettagli su come stimare la dimensione codificata delle righe in Amazon Keyspaces. La dimensione codificata delle righe viene utilizzata per il calcolo della fattura e dell'utilizzo della quota. È inoltre possibile utilizzare la dimensione delle righe codificate per stimare i requisiti di capacità di throughput assegnati per le tabelle.
Per calcolare la dimensione codificata delle righe in Amazon Keyspaces, puoi utilizzare le seguenti linee guida.
**Topics**
+ [Stima la dimensione codificata delle colonne](#calculating-row-size-columns)
+ [Stima la dimensione codificata dei valori dei dati in base al tipo di dati](#calculating-row-size-data-types)
+ [Considera l'impatto delle funzionalità di Amazon Keyspaces sulla dimensione delle righe](#calculating-row-size-features)
+ [Scegli la formula giusta per calcolare la dimensione codificata di una riga](#calculating-row-size-formula)
+ [Esempio di calcolo della dimensione delle righe](#calculating-row-size-example)
## Stima la dimensione codificata delle colonne
Questa sezione mostra come stimare la dimensione codificata delle colonne in Amazon Keyspaces.
+ **Colonne regolari**: per le colonne normali, che sono colonne che non sono chiavi primarie, colonne di clustering o `STATIC` colonne, usa la dimensione grezza dei dati della cella in base al [tipo di dati](cql.elements.md#cql.data-types) e aggiungi i metadati richiesti. I tipi di dati e alcune differenze chiave nel modo in cui Amazon Keyspaces archivia i valori dei tipi di dati e i metadati sono elencati nella sezione successiva.
+ **Colonne chiave di partizione: le** chiavi di partizione possono contenere fino a 2048 byte di dati. Ogni colonna chiave nella chiave di partizione richiede fino a 3 byte di metadati. Quando si calcola la dimensione della riga, è necessario presupporre che ogni colonna della chiave di partizione utilizzi tutti i 3 byte di metadati.
+ **Colonne di clustering: le colonne** di clustering possono memorizzare fino a 850 byte di dati. Oltre alla dimensione del valore dei dati, ogni colonna di clustering richiede fino al 20% della dimensione del valore dei dati per i metadati. Quando si calcola la dimensione della riga, è necessario aggiungere 1 byte di metadati per ogni 5 byte di valore dei dati della colonna di clustering.
**Nota**
Per supportare interrogazioni efficienti e indicizzazione integrata, Amazon Keyspaces memorizza due volte il valore dei dati di ogni chiave di partizione e colonna chiave di clustering.
+ **Nomi di colonna**: lo spazio richiesto per ogni nome di colonna viene memorizzato utilizzando un identificatore di colonna e aggiunto a ciascun valore di dati memorizzato nella colonna. Il valore di archiviazione dell'identificatore di colonna dipende dal numero complessivo di colonne della tabella:
+ 1—62 colonne: 1 byte
+ 63-124 colonne: 2 byte
+ 125-186 colonne: 3 byte
Per ogni 62 colonne aggiuntive aggiungere 1 byte. Tieni presente che in Amazon Keyspaces, è possibile modificare fino a 225 colonne regolari con una singola istruzione `INSERT` or`UPDATE`. Per ulteriori informazioni, consulta [Quote di servizio Amazon Keyspaces](quotas.md#table).
## Stima la dimensione codificata dei valori dei dati in base al tipo di dati
Questa sezione mostra come stimare la dimensione codificata di diversi tipi di dati in Amazon Keyspaces.
+ **Tipi di stringa**: Cassandra `ASCII` e i tipi di dati `VARCHAR` string sono tutti archiviati in Amazon Keyspaces utilizzando Unicode con codifica binaria UTF-8. `TEXT` La dimensione di una stringa in Amazon Keyspaces è uguale al numero di byte con codifica UTF-8.
+ **Tipi numerici**: Cassandra`INT`,, `BIGINT` `SMALLINT``TINYINT`, e `VARINT` i tipi di dati vengono archiviati in Amazon Keyspaces come valori di dati a lunghezza variabile, con un massimo di 38 cifre significative. Gli zero iniziali e finali vengono tagliati. La dimensione di ognuno di questi tipi di dati è di circa 1 byte per due cifre significative \$1 1 byte.
+ **Tipo di blob**: A `BLOB` in Amazon Keyspaces viene archiviato con la lunghezza in byte non elaborata del valore.
+ **Tipo booleano**: la dimensione di uno o più `Boolean` valori è di 1 byte. `Null`
+ **Tipi di raccolta**: colonna che memorizza tipi di dati di raccolta come `LIST` o `MAP` richiede 3 byte di metadati, indipendentemente dal contenuto. La dimensione di un `LIST` or `MAP` è (id della colonna) \$1 sum (dimensione degli elementi annidati) \$1 (3 byte). La dimensione di un `LIST` or vuoto `MAP` è (id di colonna) \$1 (3 byte). Ogni singolo `LIST` `MAP` elemento richiede anche 1 byte di metadati.
+ **Tipi definiti dall'utente**: un [tipo definito dall'utente (UDT)](udts.md) richiede 3 byte per i metadati, indipendentemente dal contenuto. Per ogni elemento UDT, Amazon Keyspaces richiede 1 byte aggiuntivo di metadati.
Per calcolare la dimensione codificata di un UDT, inizia con `field name` e `field value` per i campi di un UDT:
+ **nome di campo**: ogni nome di campo dell'UDT di primo livello viene memorizzato utilizzando un identificatore. Il valore di archiviazione dell'identificatore dipende dal numero complessivo di campi nell'UDT di primo livello e può variare tra 1 e 3 byte:
+ 1—62 campi: 1 byte
+ 63—124 campi: 2 byte
+ 125— numero massimo di campi: 3 byte
+ **valore del campo**: i byte necessari per memorizzare i valori dei campi dell'UDT di primo livello dipendono dal tipo di dati archiviati:
+ **Tipo di dati scalare**: i byte necessari per l'archiviazione sono gli stessi dello stesso tipo di dati archiviato in una colonna normale.
+ **UDT congelato**: per ogni UDT annidato congelato, l'UDT nidificato ha le stesse dimensioni del protocollo binario CQL. Per un UDT nidificato, vengono memorizzati 4 byte per ogni campo (compresi i campi vuoti) e il valore del campo archiviato è il formato di serializzazione del protocollo binario CQL del valore del campo.
+ **Collezioni Frozen:**
+ **LIST** e **SET**: per un ambiente congelato `LIST` o annidato`SET`, vengono archiviati 4 byte per ogni elemento della raccolta più il formato di serializzazione del protocollo binario CQL del valore della raccolta.
+ **MAP** — Per un blocco congelato annidato`MAP`, ogni coppia chiave-valore ha i seguenti requisiti di archiviazione:
+ Per ogni chiave, allocare 4 byte, quindi aggiungere il formato di serializzazione del protocollo binario CQL della chiave.
+ Per ogni valore allocare 4 byte, quindi aggiungere il formato di serializzazione del protocollo binario CQL del valore.
+ **Parola chiave FROZEN**: per le raccolte congelate annidate all'interno di raccolte congelate, Amazon Keyspaces non richiede byte aggiuntivi per i metadati.
+ **Parola chiave STATICA**: i dati `STATIC` delle colonne non vengono conteggiati ai fini della dimensione massima delle righe di 1 MB. Per calcolare la dimensione dei dati delle colonne statiche, vedi[Calcola la dimensione statica delle colonne per partizione logica in Amazon Keyspaces](static-columns-estimate.md).
## Considera l'impatto delle funzionalità di Amazon Keyspaces sulla dimensione delle righe
Questa sezione mostra come le funzionalità di Amazon Keyspaces influiscono sulla dimensione codificata di una riga.
+ **Timestamp lato client: i timestamp** lato client vengono memorizzati per ogni colonna di ogni riga quando la funzionalità è attivata. Questi timestamp occupano circa 20-40 byte (a seconda dei dati) e contribuiscono ai costi di archiviazione e velocità effettiva della riga. Per ulteriori informazioni sui timestamp lato client, vedere. [Timestamp lato client in Amazon Keyspaces](client-side-timestamps.md)
+ **Time to Live (TTL)**: i metadati TTL occupano circa 8 byte per riga quando la funzionalità è attivata. Inoltre, i metadati TTL vengono archiviati per ogni colonna di ogni riga. I metadati TTL occupano circa 8 byte per ogni colonna che memorizza un tipo di dati scalare o una raccolta congelata. Se la colonna memorizza un tipo di dati di raccolta che non è bloccato, per ogni elemento della raccolta TTL richiede circa 8 byte aggiuntivi per i metadati. Per una colonna che memorizza un tipo di dati di raccolta quando il TTL è abilitato, puoi utilizzare la formula seguente.
```
total encoded size of column = (column id) + sum (nested elements + collection metadata (1 byte) + TTL metadata (8 bytes)) + collection column metadata (3 bytes)
```
I metadati TTL contribuiscono al costo di archiviazione e velocità effettiva della riga. Per ulteriori informazioni su TTL, consulta [Fai scadere i dati con Time to Live (TTL) per Amazon Keyspaces (per Apache Cassandra)](TTL.md).
## Scegli la formula giusta per calcolare la dimensione codificata di una riga
Questa sezione mostra le diverse formule che puoi utilizzare per stimare i requisiti di storage o di capacità di throughput per una riga di dati in Amazon Keyspaces.
La dimensione totale codificata di una riga di dati può essere stimata in base a una delle seguenti formule, in base al tuo obiettivo:
+ **Capacità di trasmissione**: per stimare la dimensione codificata di una riga per valutare le unità di read/write richiesta richieste (): RRUs/WRUs) or read/write capacity units (RCUs/WCUs
```
total encoded size of row = partition key columns + clustering columns + regular columns
```
+ **Dimensione di archiviazione**: per stimare la dimensione codificata di una riga e prevederla`BillableTableSizeInBytes`, aggiungi i metadati richiesti per l'archiviazione della riga:
```
total encoded size of row = partition key columns + clustering columns + regular columns + row metadata (100 bytes)
```
**Importante**
Tutti i metadati delle colonne, ad esempio gli ID delle colonne, i metadati delle chiavi di partizione, i metadati delle colonne di clustering, nonché i timestamp, il TTL e i metadati di riga sul lato client, vengono conteggiati ai fini della dimensione massima delle righe di 1 MB.
## Esempio di calcolo della dimensione delle righe
Considerate il seguente esempio di tabella in cui tutte le colonne sono di tipo intero. La tabella ha due colonne chiave di partizione, due colonne di clustering e una colonna normale. Poiché questa tabella ha cinque colonne, lo spazio richiesto per l'identificatore del nome della colonna è di 1 byte.
```
CREATE TABLE mykeyspace.mytable(pk_col1 int, pk_col2 int, ck_col1 int, ck_col2 int, reg_col1 int, primary key((pk_col1, pk_col2),ck_col1, ck_col2));
```
In questo esempio, calcoliamo la dimensione dei dati quando scriviamo una riga nella tabella, come illustrato nella seguente dichiarazione:
```
INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, ck_col1, ck_col2, reg_col1) values(1,2,3,4,5);
```
Per stimare i byte totali richiesti da questa operazione di scrittura, è possibile utilizzare i seguenti passaggi.
1. Calcola la dimensione di una colonna chiave di partizione aggiungendo i byte per il tipo di dati archiviato nella colonna e i byte dei metadati. Ripeti questa operazione per tutte le colonne chiave di partizione.
1. Calcola la dimensione della prima colonna della chiave di partizione (pk\$1col1):
```
(2 bytes for the integer data type) x 2 + 1 byte for the column id + 3 bytes for partition key metadata = 8 bytes
```
1. Calcola la dimensione della seconda colonna della chiave di partizione (pk\$1col2):
```
(2 bytes for the integer data type) x 2 + 1 byte for the column id + 3 bytes for partition key metadata = 8 bytes
```
1. Aggiungi entrambe le colonne per ottenere la dimensione totale stimata delle colonne chiave di partizione:
```
8 bytes + 8 bytes = 16 bytes for the partition key columns
```
1. Calcola la dimensione della colonna di clustering aggiungendo i byte per il tipo di dati archiviato nella colonna e i byte dei metadati. Ripeti l'operazione per tutte le colonne di clustering.
1. Calcola la dimensione della prima colonna della colonna di clustering (ck\$1col1):
```
(2 bytes for the integer data type) x 2 + 20% of the data value (2 bytes) for clustering column metadata + 1 byte for the column id = 6 bytes
```
1. Calcola la dimensione della seconda colonna della colonna di clustering (ck\$1col2):
```
(2 bytes for the integer data type) x 2 + 20% of the data value (2 bytes) for clustering column metadata + 1 byte for the column id = 6 bytes
```
1. Aggiungi entrambe le colonne per ottenere la dimensione totale stimata delle colonne di clustering:
```
6 bytes + 6 bytes = 12 bytes for the clustering columns
```
1. Aggiungi la dimensione delle colonne normali. In questo esempio abbiamo solo una colonna che memorizza un numero intero a una cifra, che richiede 2 byte con 1 byte per l'ID della colonna.
1. Infine, per ottenere la dimensione totale delle righe codificate, sommate i byte per tutte le colonne. Per stimare la dimensione fatturabile per l'archiviazione, aggiungi i 100 byte aggiuntivi per i metadati delle righe:
```
16 bytes for the partition key columns + 12 bytes for clustering columns + 3 bytes for the regular column + 100 bytes for row metadata = 131 bytes.
```
Per scoprire come monitorare le risorse serverless con Amazon CloudWatch, consulta[Monitoraggio di Amazon Keyspaces con Amazon CloudWatch](monitoring-cloudwatch.md).
# Stima del consumo di capacità per la velocità effettiva di lettura e scrittura in Amazon Keyspaces
Quando leggi o scrivi dati in Amazon Keyspaces, la quantità di unità di read/write richiesta (RRUs/WRUs) or read/write capacity units (RCUs/WCUs) consumate dalla tua query dipende dalla quantità totale di dati che Amazon Keyspaces deve elaborare per eseguire la query. In alcuni casi, i dati restituiti al client possono essere un sottoinsieme dei dati che Amazon Keyspaces ha dovuto leggere per elaborare la query. Per le scritture condizionali, Amazon Keyspaces consuma capacità di scrittura anche se il controllo condizionale fallisce.
Per stimare la quantità totale di dati elaborati per una richiesta, devi considerare la dimensione codificata di una riga e il numero totale di righe. Questo argomento illustra alcuni esempi di scenari e modelli di accesso comuni per mostrare come Amazon Keyspaces elabora le query e come ciò influisca sul consumo di capacità. Puoi seguire gli esempi per stimare i requisiti di capacità delle tue tabelle e utilizzare Amazon CloudWatch per osservare il consumo di capacità di lettura e scrittura per questi casi d'uso.
Per informazioni su come calcolare la dimensione codificata delle righe in Amazon Keyspaces, consulta. [Stima della dimensione delle righe in Amazon Keyspaces](calculating-row-size.md)
**Topics**
+ [Stima il consumo di capacità delle query di intervallo in Amazon Keyspaces](range_queries.md)
+ [Stima il consumo di capacità di lettura delle query limite](limit_queries.md)
+ [Stima il consumo di capacità di lettura delle scansioni delle tabelle](table_scans.md)
+ [Stima del consumo di capacità delle transazioni leggere in Amazon Keyspaces](lightweight_transactions.md)
+ [Stima del consumo di capacità per le colonne statiche in Amazon Keyspaces](static-columns.md)
+ [Stima e fornisci la capacità per una tabella multiregionale in Amazon Keyspaces](tables-multi-region-capacity.md)
+ [Stima del consumo di capacità di lettura e scrittura con Amazon CloudWatch in Amazon Keyspaces](estimate_consumption_cw.md)
# Stima il consumo di capacità delle query di intervallo in Amazon Keyspaces
Per esaminare il consumo di capacità di lettura di una query con intervallo, utilizziamo la seguente tabella di esempio che utilizza la modalità di capacità su richiesta.
```
pk1 | pk2 | pk3 | ck1 | ck2 | ck3 | value
-----+-----+-----+-----+-----+-----+-------
a | b | 1 | a | b | 50 |
a | b | 1 | a | b | 60 | value_1
a | b | 1 | a | b | 70 |
```
Ora esegui la seguente query su questa tabella.
```
SELECT * FROM amazon_keyspaces.example_table_1 WHERE pk1='a' AND pk2='b' AND pk3=1 AND ck1='a' AND ck2='b' AND ck3 > 50 AND ck3 < 70;
```
Riceverai il seguente set di risultati dalla query e l'operazione di lettura eseguita da Amazon Keyspaces consuma 2 RRUs in `LOCAL_QUORUM` modalità di coerenza.
```
pk1 | pk2 | pk3 | ck1 | ck2 | ck3 | value
-----+-----+-----+-----+-----+-----+-------
a | b | 1 | a | b | 60 | value_1
```
Amazon Keyspaces ne consuma 2 RRUs per valutare le righe con i valori `ck3=60` ed `ck3=70` elaborare la query. Tuttavia, Amazon Keyspaces restituisce solo la riga in cui la `WHERE` condizione specificata nella query è vera, ovvero la riga con valore. `ck3=60` Per valutare l'intervallo specificato nella query, Amazon Keyspaces legge la riga che corrisponde al limite superiore dell'intervallo, in questo caso`ck3 = 70`, ma non restituisce quella riga nel risultato. Il consumo di capacità di lettura si basa sui dati letti durante l'elaborazione della query, non sui dati restituiti.
# Stima il consumo di capacità di lettura delle query limite
Durante l'elaborazione di una query che utilizza la `LIMIT` clausola, Amazon Keyspaces legge le righe fino alla dimensione massima della pagina quando cerca di soddisfare la condizione specificata nella query. Se Amazon Keyspaces non riesce a trovare dati corrispondenti sufficienti che soddisfino il `LIMIT` valore nella prima pagina, potrebbero essere necessarie una o più chiamate impaginate. Per continuare le letture nella pagina successiva, puoi utilizzare un token di impaginazione. La dimensione predefinita della pagina è 1 MB. Per ridurre la capacità di lettura quando si utilizzano le `LIMIT` clausole, è possibile ridurre le dimensioni della pagina. Per ulteriori informazioni sull'impaginazione, vedere. [Impaginare i risultati in Amazon Keyspaces](paginating-results.md)
Per un esempio, diamo un'occhiata alla seguente query.
```
SELECT * FROM my_table WHERE partition_key=1234 LIMIT 1;
```
Se non imposti la dimensione della pagina, Amazon Keyspaces legge 1 MB di dati anche se ti restituisce solo 1 riga. Per fare in modo che Amazon Keyspaces legga solo una riga, puoi impostare la dimensione della pagina su 1 per questa query. In questo caso, Amazon Keyspaces leggerebbe solo una riga, a condizione che non ci siano righe scadute in base a Time-to-live impostazioni o timestamp lato client.
Il `PAGE SIZE` parametro determina quante righe Amazon Keyspaces scansiona dal disco per ogni richiesta, non quante righe Amazon Keyspaces restituisce al client. Amazon Keyspaces applica i filtri che fornisci, ad esempio la disuguaglianza su colonne non chiave o `LIMIT` dopo la scansione dei dati su disco. Se non lo imposti esplicitamente`PAGE SIZE`, Amazon Keyspaces legge fino a 1 MB di dati prima di applicare i filtri. Ad esempio, se utilizzi `LIMIT 1` Without Specify`PAGE SIZE`, Amazon Keyspaces potrebbe leggere migliaia di righe dal disco prima di applicare la clausola limite e restituire solo una riga.
Per evitare un eccesso di lettura, riduci il numero di righe `PAGE SIZE` che Amazon Keyspaces scansiona per ogni recupero. Ad esempio, se lo definisci `LIMIT 5` nella tua query, imposta un valore compreso tra 5 e 10 in modo che Amazon Keyspaces scansioni solo 5-10 righe per ogni chiamata impaginata. `PAGE SIZE` Puoi modificare questo numero per ridurre il numero di recuperi. Per limiti superiori alla dimensione della pagina, Amazon Keyspaces mantiene il conteggio totale dei risultati con lo stato di impaginazione. Nel caso `LIMIT` di 10.000 righe, Amazon Keyspaces può recuperare questi risultati in due pagine da 5.000 righe ciascuna. Il limite di 1 MB è il limite superiore per qualsiasi set di dimensioni di pagina.
# Stima il consumo di capacità di lettura delle scansioni delle tabelle
Le interrogazioni che generano scansioni complete della tabella, ad esempio le query che utilizzano l'`ALLOW FILTERING`opzione, sono un altro esempio di query che elaborano più letture di quelle restituite come risultati. Inoltre, il consumo di capacità di lettura si basa sui dati letti, non sui dati restituiti.
Per l'esempio di scansione delle tabelle, utilizziamo la seguente tabella di esempio in modalità di capacità su richiesta.
```
pk | ck | value
---+----+---------
pk | 10 |
pk | 20 | value_1
pk | 30 |
```
Amazon Keyspaces crea una tabella in modalità di capacità su richiesta con quattro partizioni per impostazione predefinita. In questa tabella di esempio, tutti i dati sono archiviati in una partizione e le tre partizioni rimanenti sono vuote.
Ora esegui la seguente query sulla tabella.
```
SELECT * from amazon_keyspaces.example_table_2;
```
Questa query genera un'operazione di scansione della tabella in cui Amazon Keyspaces analizza tutte e quattro le partizioni della tabella e ne consuma 6 in modalità di coerenza. RRUs `LOCAL_QUORUM` Innanzitutto, Amazon Keyspaces ne consuma 3 RRUs per leggere le tre righe con. `pk=‘pk’` Quindi, Amazon Keyspaces utilizza i 3 componenti aggiuntivi RRUs per la scansione delle tre partizioni vuote della tabella. Poiché questa query genera una scansione della tabella, Amazon Keyspaces analizza tutte le partizioni della tabella, incluse le partizioni senza dati.
# Stima del consumo di capacità delle transazioni leggere in Amazon Keyspaces
Le transazioni leggere (LWT) consentono di eseguire operazioni di scrittura condizionali sui dati della tabella. Le operazioni di aggiornamento condizionale sono utili per l'inserimento, l'aggiornamento e l'eliminazione dei record in base a condizioni che valutano lo stato corrente.
In Amazon Keyspaces, tutte le operazioni di scrittura richiedono la coerenza LOCAL\$1QUORUM e non sono previsti costi aggiuntivi per l'utilizzo. LWTs La differenza LWTs è che quando viene eseguito un controllo delle condizioni LWT`FALSE`, Amazon Keyspaces utilizza unità di capacità di scrittura WCUs () o unità di richiesta di scrittura (). WRUs Il numero di dati WCUs/WRUs consumati dipende dalla dimensione della riga.
Ad esempio, se la dimensione della riga è 2 KB, la scrittura condizionale non riuscita consuma due WCUs/. WRUs Se la riga non esiste attualmente nella tabella, l'operazione consuma una/. WCUs WRUs
Per determinare il numero di richieste che hanno provocato errori nel controllo delle condizioni, puoi monitorare la `ConditionalCheckFailed` metrica in. CloudWatch
## Stima i costi LWT per le tabelle con Time to Live (TTL)
LWTs può richiedere unità di capacità di lettura aggiuntive (RCUs) o unità di richiesta di lettura (RRUs) per tabelle configurate con TTL che non utilizzano timestamp lato client. Quando si utilizzano i `IF EXISTS` risultati del controllo delle condizioni delle `IF NOT EXISTS` parole chiave`FALSE`, vengono consumate le seguenti unità di capacità:
+ RCUs/RRUs – If the row exists, the RCUs/RRUsi consumi si basano sulla dimensione della riga esistente.
+ RCUs/RRUs – If the row doesn't exist, a single RCU/RRUviene consumato.
Se la condizione valutata determina un'operazione di scrittura riuscita, WCUs/WRUs vengono consumati in base alla dimensione della nuova riga.
# Stima del consumo di capacità per le colonne statiche in Amazon Keyspaces
In una tabella Amazon Keyspaces con colonne di clustering, puoi utilizzare la `STATIC` parola chiave per creare una colonna statica. Il valore memorizzato in una colonna statica è condiviso tra tutte le righe di una partizione logica. Quando aggiorni il valore di questa colonna, Amazon Keyspaces applica automaticamente la modifica a tutte le righe della partizione.
Questa sezione descrive come calcolare la dimensione codificata dei dati quando scrivi su colonne statiche. Questo processo viene gestito separatamente dal processo di scrittura dei dati nelle colonne non statiche di una riga. Oltre alle quote di dimensione per i dati statici, le operazioni di lettura e scrittura sulle colonne statiche influiscono anche sulla capacità di misurazione e di velocità effettiva delle tabelle in modo indipendente. Per le differenze funzionali con Apache Cassandra quando si utilizzano colonne statiche e risultati di lettura con intervalli di pagine, vedere. [Paginazione](functional-differences.md#functional-differences.paging)
**Topics**
+ [Calcola la dimensione statica delle colonne per partizione logica in Amazon Keyspaces](static-columns-estimate.md)
+ [Stima dei requisiti di capacità e throughput per read/write le operazioni su dati statici in Amazon Keyspaces](static-columns-metering.md)
# Calcola la dimensione statica delle colonne per partizione logica in Amazon Keyspaces
Questa sezione fornisce dettagli su come stimare la dimensione codificata delle colonne statiche in Amazon Keyspaces. La dimensione codificata viene utilizzata per il calcolo della bolletta e dell'utilizzo delle quote. È inoltre necessario utilizzare la dimensione codificata quando si calcolano i requisiti di capacità di throughput assegnati per le tabelle. Per calcolare la dimensione codificata delle colonne statiche in Amazon Keyspaces, puoi utilizzare le seguenti linee guida.
+ Le chiavi di partizione possono contenere fino a 2048 byte di dati. Ogni colonna chiave nella chiave di partizione richiede fino a 3 byte di metadati. Questi byte di metadati vengono conteggiati ai fini della quota di dimensione dei dati statici di 1 MB per partizione. Quando si calcola la dimensione dei dati statici, è necessario presupporre che ogni colonna chiave di partizione utilizzi tutti i 3 byte di metadati.
+ Utilizza la dimensione grezza dei valori dei dati della colonna statica in base al tipo di dati. Per ulteriori informazioni sui tipi di dati, consulta [Tipi di dati](cql.elements.md#cql.data-types).
+ Aggiungi 104 byte alla dimensione dei dati statici per i metadati.
+ Le colonne di clustering e le colonne con chiavi non primarie regolari non vengono conteggiate ai fini della dimensione dei dati statici. Per informazioni su come stimare la dimensione dei dati non statici all'interno delle righe, consulta. [Stima della dimensione delle righe in Amazon Keyspaces](calculating-row-size.md)
La dimensione totale codificata di una colonna statica si basa sulla seguente formula:
```
partition key columns + static columns + metadata = total encoded size of static data
```
Considerate il seguente esempio di tabella in cui tutte le colonne sono di tipo intero. La tabella ha due colonne chiave di partizione, due colonne di clustering, una colonna normale e una colonna statica.
```
CREATE TABLE mykeyspace.mytable(pk_col1 int, pk_col2 int, ck_col1 int, ck_col2 int, reg_col1 int, static_col1 int static, primary key((pk_col1, pk_col2),ck_col1, ck_col2));
```
In questo esempio, calcoliamo la dimensione dei dati statici della seguente dichiarazione:
```
INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, static_col1) values(1,2,6);
```
Per stimare i byte totali richiesti da questa operazione di scrittura, è possibile utilizzare i seguenti passaggi.
1. Calcola la dimensione di una colonna chiave di partizione aggiungendo i byte per il tipo di dati archiviato nella colonna e i byte dei metadati. Ripeti questa operazione per tutte le colonne chiave di partizione.
1. Calcola la dimensione della prima colonna della chiave di partizione (pk\$1col1):
```
4 bytes for the integer data type + 3 bytes for partition key metadata = 7 bytes
```
1. Calcola la dimensione della seconda colonna della chiave di partizione (pk\$1col2):
```
4 bytes for the integer data type + 3 bytes for partition key metadata = 7 bytes
```
1. Aggiungi entrambe le colonne per ottenere la dimensione totale stimata delle colonne chiave di partizione:
```
7 bytes + 7 bytes = 14 bytes for the partition key columns
```
1. Aggiungi la dimensione delle colonne statiche. In questo esempio, abbiamo solo una colonna statica che memorizza un numero intero (che richiede 4 byte).
1. Infine, per ottenere la dimensione totale codificata dei dati delle colonne statiche, sommate i byte per le colonne chiave primarie e le colonne statiche e aggiungete i 104 byte aggiuntivi per i metadati:
```
14 bytes for the partition key columns + 4 bytes for the static column + 104 bytes for metadata = 122 bytes.
```
È inoltre possibile aggiornare dati statici e non statici con la stessa istruzione. Per stimare la dimensione totale dell'operazione di scrittura, è necessario innanzitutto calcolare la dimensione dell'aggiornamento dei dati non statici. Quindi calcola la dimensione dell'aggiornamento della riga come mostrato nell'esempio in [Stima della dimensione delle righe in Amazon Keyspaces](calculating-row-size.md) e aggiungi i risultati.
In questo caso, è possibile scrivere un totale di 2 MB: 1 MB è la quota massima per la dimensione delle righe e 1 MB è la quota per la dimensione massima dei dati statici per partizione logica.
Per calcolare la dimensione totale di un aggiornamento di dati statici e non statici nella stessa istruzione, è possibile utilizzare la formula seguente:
```
(partition key columns + static columns + metadata = total encoded size of static data) + (partition key columns + clustering columns + regular columns + row metadata = total encoded size of row)
= total encoded size of data written
```
Considerate il seguente esempio di tabella in cui tutte le colonne sono di tipo intero. La tabella ha due colonne chiave di partizione, due colonne di clustering, una colonna normale e una colonna statica.
```
CREATE TABLE mykeyspace.mytable(pk_col1 int, pk_col2 int, ck_col1 int, ck_col2 int, reg_col1 int, static_col1 int static, primary key((pk_col1, pk_col2),ck_col1, ck_col2));
```
In questo esempio, calcoliamo la dimensione dei dati quando scriviamo una riga nella tabella, come illustrato nella seguente dichiarazione:
```
INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, ck_col1, ck_col2, reg_col1, static_col1) values(2,3,4,5,6,7);
```
Per stimare i byte totali richiesti da questa operazione di scrittura, è possibile utilizzare i seguenti passaggi.
1. Calcola la dimensione totale codificata dei dati statici come mostrato in precedenza. In questo esempio, sono 122 byte.
1. Aggiungi la dimensione della dimensione totale codificata della riga in base all'aggiornamento dei dati non statici, seguendo la procedura descritta in. [Stima della dimensione delle righe in Amazon Keyspaces](calculating-row-size.md) In questo esempio, la dimensione totale dell'aggiornamento della riga è di 134 byte.
```
122 bytes for static data + 134 bytes for nonstatic data = 256 bytes.
```
# Stima dei requisiti di capacità e throughput per read/write le operazioni su dati statici in Amazon Keyspaces
I dati statici sono associati alle partizioni logiche in Cassandra, non a singole righe. Le partizioni logiche in Amazon Keyspaces possono avere dimensioni praticamente illimitate se si estendono su più partizioni di storage fisiche. Di conseguenza, i contatori di Amazon Keyspaces scrivono le operazioni su dati statici e non statici separatamente. Inoltre, le scritture che includono dati statici e non statici richiedono operazioni sottostanti aggiuntive per garantire la coerenza dei dati.
Se si esegue un'operazione di scrittura mista di dati statici e non statici, si ottengono due operazioni di scrittura separate, una per dati non statici e una per dati statici. Ciò vale sia per le modalità di capacità on-demand che per quelle con capacità assegnata. read/write
L'esempio seguente fornisce dettagli su come stimare le unità di capacità di lettura (RCUs) e le unità di capacità di scrittura (WCUs) richieste quando si calcolano i requisiti di capacità di throughput assegnata per le tabelle in Amazon Keyspaces con colonne statiche. Puoi stimare la capacità necessaria alla tua tabella per elaborare scritture che includono dati statici e non statici utilizzando la seguente formula:
```
2 x WCUs required for nonstatic data + 2 x WCUs required for static data
```
Ad esempio, se l'applicazione scrive 27 KBs dati al secondo e ogni scrittura include 25,5 KBs di dati non statici e 1,5 KBs di dati statici, la tabella ne richiede 56 WCUs (2 x 26 WCUs \$1 2 x 2). WCUs
Amazon Keyspaces misura le letture di dati statici e non statici allo stesso modo delle letture di più righe. Di conseguenza, il prezzo della lettura di dati statici e non statici nella stessa operazione si basa sulla dimensione aggregata dei dati elaborati per eseguire la lettura.
Per scoprire come monitorare le risorse serverless con Amazon CloudWatch, consulta[Monitoraggio di Amazon Keyspaces con Amazon CloudWatch](monitoring-cloudwatch.md).
# Stima e fornisci la capacità per una tabella multiregionale in Amazon Keyspaces
Puoi configurare la capacità di throughput di una tabella multiregionale in due modi:
+ modalità di capacità su richiesta, misurata in unità di richiesta di scrittura () WRUs
+ Modalità di capacità fornita con scalabilità automatica, misurata in unità di capacità di scrittura () WCUs
È possibile utilizzare la modalità di capacità assegnata con scalabilità automatica o la modalità di capacità su richiesta per garantire che una tabella multiarea abbia una capacità sufficiente per eseguire scritture replicate su tutti. Regioni AWS
**Nota**
La modifica della modalità di capacità della tabella in una delle regioni modifica la modalità di capacità per tutte le repliche.
Per impostazione predefinita, Amazon Keyspaces utilizza la modalità on-demand per tabelle multiregionali. Con la modalità on demand, non è necessario specificare la velocità effettiva di lettura e scrittura che si prevede che l'applicazione esegua. Amazon Keyspaces si adatta istantaneamente ai tuoi carichi di lavoro man mano che aumentano o diminuiscono fino a qualsiasi livello di traffico raggiunto in precedenza. Se il livello di traffico di un carico di lavoro raggiunge un nuovo picco, Amazon Keyspaces si adatta rapidamente per adattarsi al carico di lavoro.
Se scegli la modalità di capacità assegnata per una tabella, devi configurare il numero di unità di capacità di lettura (RCUs) e unità di capacità di scrittura (WCUs) al secondo richieste dall'applicazione.
Per pianificare le esigenze di capacità di throughput di una tabella multiregionale, è innanzitutto necessario stimare il numero di velocità WCUs al secondo necessario per ciascuna regione. Quindi aggiungi le scritture da tutte le regioni in cui viene replicata la tabella e utilizza la somma per fornire la capacità per ciascuna regione. Ciò è necessario perché ogni scrittura eseguita in una regione deve essere ripetuta anche in ogni regione di replica.
Se la tabella non ha una capacità sufficiente per gestire le scritture da tutte le regioni, si verificheranno delle eccezioni di capacità. Inoltre, aumenteranno i tempi di attesa per la replica interregionale.
Ad esempio, se disponi di una tabella multiregionale in cui sono previste 5 scritture al secondo negli Stati Uniti orientali (Virginia settentrionale), 10 scritture al secondo negli Stati Uniti orientali (Ohio) e 5 scritture al secondo in Europa (Irlanda), dovresti aspettarti che la tabella consumi 20 scritture WCUs in ciascuna regione: Stati Uniti orientali (Virginia settentrionale), Stati Uniti orientali (Ohio) ed Europa (Irlanda). Ciò significa che in questo esempio è necessario fornire 20 WCUs per ciascuna replica della tabella. Puoi monitorare il consumo di capacità della tua tabella utilizzando Amazon CloudWatch. Per ulteriori informazioni, consulta [Monitoraggio di Amazon Keyspaces con Amazon CloudWatch](monitoring-cloudwatch.md).
Ogni scrittura viene fatturata come 1 WCU, quindi in questo esempio vedresti un totale di 60 WCUs fatturate. Per ulteriori informazioni sui prezzi, consulta i prezzi di [Amazon Keyspaces (per Apache Cassandra](https://aws.amazon.com/keyspaces/pricing)).
Per ulteriori informazioni sulla capacità fornita con la [Gestisci automaticamente la capacità di throughput con la scalabilità automatica di Amazon Keyspaces](autoscaling.md) scalabilità automatica di Amazon Keyspaces, consulta.
**Nota**
Se una tabella è in esecuzione in modalità di capacità fornita con scalabilità automatica, la capacità di scrittura assegnata può fluttuare all'interno delle impostazioni di ridimensionamento automatico per ciascuna regione.
# Stima del consumo di capacità di lettura e scrittura con Amazon CloudWatch in Amazon Keyspaces
Per stimare e monitorare il consumo di capacità di lettura e scrittura, puoi utilizzare una CloudWatch dashboard. Per ulteriori informazioni sui parametri disponibili per Amazon Keyspaces, consulta. [Metriche e dimensioni di Amazon Keyspaces](metrics-dimensions.md)
Per monitorare le unità di capacità di lettura e scrittura utilizzate da una dichiarazione specifica con CloudWatch, puoi seguire questi passaggi.
1. Crea una nuova tabella con dati di esempio
1. Configura un CloudWatch pannello di controllo Amazon Keyspaces per la tabella. Per iniziare, puoi utilizzare un modello di dashboard disponibile su [Github](https://github.com/aws-samples/amazon-keyspaces-cloudwatch-cloudformation-templates).
1. Esegui l'istruzione CQL, ad esempio utilizzando l'`ALLOW FILTERING`opzione, e controlla le unità di capacità di lettura utilizzate per la scansione completa della tabella nella dashboard.
# Configura le modalità di read/write capacità in Amazon Keyspaces
Amazon Keyspaces offre due modalità di read/write capacità per l'elaborazione di letture e scritture sulle tabelle:
+ Su richiesta (impostazione predefinita)
+ Assegnata
La modalità read/write di capacità scelta controlla il modo in cui ti viene addebitato il throughput di lettura e scrittura e come viene gestita la capacità di throughput della tabella.
**Topics**
+ [Configura la modalità di capacità su richiesta](ReadWriteCapacityMode.OnDemand.md)
+ [Configura la modalità di capacità assegnata](ReadWriteCapacityMode.Provisioned.md)
+ [Visualizza la modalità di capacità di una tabella in Amazon Keyspaces](ReadWriteCapacityMode.ProvisionedThroughput.ManagingCapacity.md)
+ [Modifica la modalità di capacità di una tabella in Amazon Keyspaces](ReadWriteCapacityMode.SwitchReadWriteCapacityMode.md)
+ [Configurazione del preriscaldamento per le tabelle in Amazon Keyspaces](warm-throughput.md)
# Configura la modalità di capacità su richiesta
La modalità di capacità *on demand* di Amazon Keyspaces (per Apache Cassandra) è un'opzione di fatturazione flessibile in grado di soddisfare migliaia di richieste al secondo senza pianificazione della capacità. Questa opzione offre pay-per-request prezzi per le richieste di lettura e scrittura in modo da pagare solo per ciò che usi.
Quando scegli la modalità on-demand, Amazon Keyspaces può scalare istantaneamente la capacità di throughput della tabella fino a qualsiasi livello di traffico raggiunto in precedenza, per poi ridurla quando il traffico delle applicazioni diminuisce. Se il livello di traffico di un carico di lavoro raggiunge un nuovo picco, il servizio si adatta rapidamente per aumentare la capacità di throughput della tabella. Puoi abilitare la modalità di capacità su richiesta sia per le tabelle nuove che per quelle esistenti.
La modalità su richiesta è una buona opzione se si verifica una delle seguenti condizioni:
+ Si creano nuove tabelle con carichi di lavoro non noti.
+ Si dispone di un traffico delle applicazioni non prevedibile.
+ Si preferisce la facilità di pagamento per l’utilizzo effettivo.
Per iniziare con la modalità on demand, puoi creare una nuova tabella o aggiornare una tabella esistente per utilizzare la modalità di capacità su richiesta utilizzando la console o con alcune righe di codice Cassandra Query Language (CQL). Per ulteriori informazioni, consulta [Tabelle](cql.ddl.table.md).
**Topics**
+ [Unità di richiesta di lettura e unità di richiesta di scrittura](#ReadWriteCapacityMode.requests)
+ [Proprietà di dimensionamento e picco di traffico](#ReadWriteCapacityMode.PeakTraffic)
+ [Velocità di trasmissione effettiva iniziale per la modalità di capacità on demand](#ReadWriteCapacityMode.InitialThroughput)
## Unità di richiesta di lettura e unità di richiesta di scrittura
Con le tabelle in modalità di capacità on demand, non è necessario specificare in anticipo la velocità di lettura e scrittura che si prevede venga utilizzata dall'applicazione. Amazon Keyspaces ti addebita le spese di lettura e scrittura eseguite sulle tabelle in termini di unità di richiesta di lettura (RRUs) e unità di richiesta di scrittura (). WRUs
+ Una *RRU* rappresenta una richiesta di `LOCAL_QUORUM` lettura o due richieste di ` LOCAL_ONE` lettura per una riga di dimensioni fino a 4 KB. Se è necessario leggere una riga di dimensioni superiori a 4 KB, l'operazione di lettura utilizza elementi aggiuntivi RRUs. Il numero totale di elementi RRUs richiesti dipende dalla dimensione della riga e dal fatto che si desideri utilizzare `LOCAL_QUORUM` o `LOCAL_ONE` leggere la coerenza. Ad esempio, per leggere una riga da 8 KB sono necessarie 2 unità che RRUs utilizzano la coerenza di `LOCAL_QUORUM` lettura e 1 RRU se si sceglie la coerenza di `LOCAL_ONE` lettura.
+ Una *WRU* rappresenta una scrittura per una riga di dimensioni fino a 1 KB. Tutte le scritture utilizzano `LOCAL_QUORUM` la coerenza e non sono previsti costi aggiuntivi per l'utilizzo di transazioni leggere (LWTs). Se è necessario scrivere una riga più grande di 1 KB, l'operazione di scrittura utilizza elementi aggiuntivi WRUs. Il numero totale di WRUs elementi richiesti dipende dalla dimensione della riga. Ad esempio, se la dimensione della riga è di 2 KB, ne occorrono 2 WRUs per eseguire una richiesta di scrittura.
Per informazioni sui livelli di coerenza supportati, vedere[Livelli di coerenza di lettura e scrittura supportati da Apache Cassandra e costi associati](consistency.md).
## Proprietà di dimensionamento e picco di traffico
Le tabelle Amazon Keyspaces che utilizzano la modalità di capacità su richiesta si adattano automaticamente al volume di traffico dell'applicazione. La modalità di capacità on demand adatta automaticamente fino al doppio del precedente picco di traffico su una tabella. Ad esempio, lo schema di traffico dell'applicazione potrebbe variare tra 5.000 e 10.000 `LOCAL_QUORUM` letture al secondo, dove 10.000 letture al secondo era il picco di traffico precedente.
Con questo modello, la modalità di capacità su richiesta consente di gestire istantaneamente un traffico sostenuto fino a 20.000 letture al secondo. Se l'applicazione registra un traffico di 20.000 letture al secondo, tale picco diventa il nuovo picco precedente, che consente al traffico successivo di raggiungere fino a 40.000 letture al secondo.
Se hai bisogno di più del doppio del picco precedente su una tabella, Amazon Keyspaces alloca automaticamente più capacità all'aumentare del volume di traffico. Questo aiuta a garantire che la tabella abbia una capacità di throughput sufficiente per elaborare le richieste aggiuntive. Tuttavia, è possibile che si verifichino errori di capacità di throughput insufficiente se si supera il doppio del picco precedente entro 30 minuti.
Ad esempio, supponete che lo schema di traffico dell'applicazione vari tra 5.000 e 10.000 letture al secondo con elevata coerenza, dove 20.000 letture al secondo rappresentavano il picco di traffico raggiunto in precedenza. In questo caso, il servizio consiglia di distanziare la crescita del traffico su almeno 30 minuti prima di aumentare fino a 40.000 letture al secondo.
Per informazioni su come stimare il consumo di capacità di lettura e scrittura di una tabella, consulta. [Stima del consumo di capacità per la velocità effettiva di lettura e scrittura in Amazon Keyspaces](capacity-examples.md)
Per ulteriori informazioni sulle quote predefinite per il tuo account e su come aumentarle, consulta[Quote per Amazon Keyspaces (per Apache Cassandra)](quotas.md).
## Velocità di trasmissione effettiva iniziale per la modalità di capacità on demand
Se crei una nuova tabella con la modalità di capacità su richiesta abilitata o passi una tabella esistente alla modalità di capacità su richiesta per la prima volta, la tabella presenta le seguenti impostazioni di picco precedenti, anche se in precedenza non serviva traffico utilizzando la modalità di capacità su richiesta:
+ **Tabella appena creata con modalità di capacità su richiesta:** il picco precedente era di 2.000 e 6.000. WRUs RRUs Puoi guidare immediatamente fino al doppio del picco precedente. In questo modo le tabelle on demand appena create possono servire fino a 4.000 WRUs e 12.000. RRUs
+ **Tabella esistente passata alla modalità di capacità su richiesta:** il picco precedente è la metà del precedente WCUs ed è stato RCUs predisposto per la tabella o le impostazioni di una tabella appena creata con la modalità di capacità su richiesta, a seconda di quale sia la più alta.
# Configura la modalità di capacità assegnata
Se scegli la modalità di capacità di *throughput* assegnata, specifichi il numero di letture e scritture al secondo necessarie per la tua applicazione. Questo ti aiuta a gestire l'utilizzo di Amazon Keyspaces in modo che rimanga pari o inferiore a una frequenza di richieste definita per mantenere la prevedibilità. Per ulteriori informazioni sulla scalabilità automatica per il throughput assegnato, consulta. [Gestisci automaticamente la capacità di throughput con la scalabilità automatica di Amazon Keyspaces](autoscaling.md)
La modalità Provisioned Throughput Capacity è una buona opzione se si verifica una delle seguenti condizioni:
+ Si dispone di un traffico delle applicazioni prevedibile.
+ Si eseguono applicazioni il cui traffico è costante o si incrementa gradualmente.
+ È possibile prevedere i requisiti di capacità.
## Unità di capacità in lettura e unità di capacità in scrittura
Per le tabelle delle modalità di capacità di throughput assegnate, si specifica la capacità di throughput in termini di unità di capacità di lettura (RCUs) e unità di capacità di scrittura (): WCUs
+ Una *RCU* rappresenta una `LOCAL_QUORUM` lettura al secondo, o due `LOCAL_ONE` letture al secondo, per una riga di dimensioni fino a 4 KB. Se è necessario leggere una riga di dimensioni superiori a 4 KB, l'operazione di lettura utilizza elementi aggiuntivi. RCUs
Il numero totale di elementi RCUs richiesti dipende dalla dimensione della riga e dal fatto che tu voglia `LOCAL_QUORUM` o `LOCAL_ONE` legga. Ad esempio, se la dimensione della riga è di 8 KB, ne occorrono 2 RCUs per supportare una `LOCAL_QUORUM` lettura al secondo e 1 RCU se si sceglie la modalità di lettura. `LOCAL_ONE`
+ Una *WCU* rappresenta una scrittura al secondo per una riga di dimensioni fino a 1 KB. Tutte le scritture utilizzano `LOCAL_QUORUM` la coerenza e non sono previsti costi aggiuntivi per l'utilizzo di transazioni leggere ()LWTs. Se è necessario scrivere una riga più grande di 1 KB, l'operazione di scrittura utilizza elementi aggiuntivi WCUs.
Il numero totale di WCUs elementi richiesti dipende dalla dimensione della riga. Ad esempio, se la dimensione della riga è di 2 KB, ne occorrono 2 WCUs per supportare una richiesta di scrittura al secondo. Per ulteriori informazioni su come stimare il consumo di capacità di lettura e scrittura di una tabella, vedere[Stima del consumo di capacità per la velocità effettiva di lettura e scrittura in Amazon Keyspaces](capacity-examples.md).
Se l'applicazione legge o scrive righe più grandi (fino alla dimensione massima delle righe di Amazon Keyspaces di 1 MB), consuma più unità di capacità. Per ulteriori informazioni su come stimare la dimensione delle righe, consulta. [Stima della dimensione delle righe in Amazon Keyspaces](calculating-row-size.md) Si supponga, ad esempio, di creare una tabella predisposta con 6 RCUs e 6. WCUs Con queste impostazioni, la tua applicazione può eseguire le seguenti operazioni:
+ Esegue `LOCAL_QUORUM` letture fino a 24 KB al secondo (4 KB × 6). RCUs
+ Esegui `LOCAL_ONE` letture fino a 48 KB al secondo (il doppio della velocità di lettura).
+ Scrivi fino a 6 KB al secondo (1 KB × 6 WCUs).
Il *throughput assegnato* è la quantità massima di capacità di throughput che un'applicazione può consumare da una tabella. Se l'applicazione supera la capacità di throughput assegnata, è possibile che si verifichino errori di capacità insufficiente.
Ad esempio, una richiesta di lettura che non ha una capacità di throughput sufficiente ha esito negativo con un'`Read_Timeout`eccezione e viene registrata nella metrica. `ReadThrottleEvents` Una richiesta di scrittura che non ha una capacità di throughput sufficiente ha esito negativo con un'`Write_Timeout`eccezione e viene registrata nella metrica. `WriteThrottleEvents`
Puoi utilizzare Amazon CloudWatch per monitorare le metriche di throughput fornite ed effettive e gli eventi di capacità insufficiente. Per ulteriori informazioni su questi parametri, consulta [Metriche e dimensioni di Amazon Keyspaces](metrics-dimensions.md).
**Nota**
Errori ripetuti dovuti a una capacità insufficiente possono portare a eccezioni specifiche dei driver lato client, ad esempio il DataStax driver Java non funziona con un. `NoHostAvailableException`
Per modificare le impostazioni della capacità di throughput per le tabelle, è possibile utilizzare l'istruzione Console di gestione AWS o l'`ALTER TABLE`istruzione using CQL. Per ulteriori informazioni, vedere. [ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter)
Per ulteriori informazioni sulle quote predefinite per il tuo account e su come aumentarle, consulta. [Quote per Amazon Keyspaces (per Apache Cassandra)](quotas.md)
# Visualizza la modalità di capacità di una tabella in Amazon Keyspaces
Puoi interrogare la tabella di sistema nello spazio delle chiavi di sistema Amazon Keyspaces per esaminare le informazioni sulla modalità di capacità relative a una tabella. Puoi anche verificare se una tabella utilizza la modalità di capacità di throughput su richiesta o fornita. Se la tabella è configurata con la modalità di capacità di throughput assegnata, è possibile visualizzare la capacità di throughput fornita per la tabella.
È inoltre possibile utilizzare la AWS CLI per visualizzare la modalità di capacità di una tabella.
Per modificare la velocità effettiva assegnata a una tabella, vedere. [Modifica la modalità di capacità di una tabella in Amazon Keyspaces](ReadWriteCapacityMode.SwitchReadWriteCapacityMode.md)
------
#### [ Cassandra Query Language (CQL) ]
**Esempio**
```
SELECT * from system_schema_mcs.tables where keyspace_name = 'mykeyspace' and table_name = 'mytable';
```
Una tabella configurata con la modalità di capacità su richiesta restituisce quanto segue.
```
{
"capacity_mode":{
"last_update_to_pay_per_request_timestamp":"1579551547603",
"throughput_mode":"PAY_PER_REQUEST"
}
}
```
Una tabella configurata con la modalità di capacità di throughput assegnata restituisce quanto segue.
```
{
"capacity_mode":{
"last_update_to_pay_per_request_timestamp":"1579048006000",
"read_capacity_units":"5000",
"throughput_mode":"PROVISIONED",
"write_capacity_units":"6000"
}
}
```
Il `last_update_to_pay_per_request_timestamp` valore viene misurato in millisecondi.
------
#### [ CLI ]
Visualizza la modalità di capacità di throughput di una tabella utilizzando AWS CLI
```
aws keyspaces get-table --keyspace-name myKeyspace --table-name myTable
```
L'output del comando può essere simile a questo per una tabella in modalità di capacità fornita.
```
"capacitySpecification": {
"throughputMode": "PROVISIONED",
"readCapacityUnits": 4000,
"writeCapacityUnits": 2000
}
```
L'output di una tabella in modalità su richiesta è simile al seguente.
```
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST",
"lastUpdateToPayPerRequestTimestamp": "2024-10-03T10:48:19.092000+00:00"
}
```
------
# Modifica la modalità di capacità di una tabella in Amazon Keyspaces
Quando passi una tabella dalla modalità di capacità fornita alla modalità di capacità su richiesta, Amazon Keyspaces apporta diverse modifiche alla struttura della tabella e delle partizioni. Questo processo può richiedere alcuni minuti. Durante il periodo di passaggio, la tabella offre un throughput coerente con gli importi di WCU e RCU precedentemente forniti.
Quando si passa dalla modalità di capacità su richiesta alla modalità di capacità fornita, la tabella offre un throughput coerente con il picco precedente raggiunto quando la tabella era impostata sulla modalità di capacità su richiesta.
I seguenti periodi di attesa si applicano quando si cambia modalità di capacità:
+ È possibile passare da una tabella appena creata in modalità on demand alla modalità di capacità fornita in qualsiasi momento. Tuttavia, è possibile tornare alla modalità on demand solo 24 ore dopo il timestamp di creazione della tabella.
+ È possibile passare da una tabella esistente in modalità on-demand alla modalità di capacità assegnata in qualsiasi momento. Tuttavia, è possibile passare dalla modalità di capacità fornita a quella su richiesta solo una volta nell'arco di 24 ore.
------
#### [ Cassandra Query Language (CQL) ]
**Modifica la modalità di capacità di throughput di una tabella utilizzando CQL**
1. Per modificare la modalità di capacità di una tabella, è `PROVIOSIONED` necessario configurare le unità di capacità di lettura e scrittura in base ai valori di picco previsti del carico di lavoro. La seguente dichiarazione ne è un esempio. È inoltre possibile eseguire questa istruzione per regolare la capacità di lettura o le unità di capacità di scrittura della tabella.
```
ALTER TABLE catalog.book_awards WITH CUSTOM_PROPERTIES={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 6000, 'write_capacity_units': 3000}};
```
Per configurare la modalità di capacità fornita con auto-scaling, vedere. [Configura il ridimensionamento automatico su una tabella esistente](autoscaling.configureTable.md)
1. Per modificare la modalità di capacità di una tabella in modalità on demand, imposta la modalità di throughput su. `PAY_PER_REQUEST` La seguente dichiarazione ne è un esempio.
```
ALTER TABLE catalog.book_awards WITH CUSTOM_PROPERTIES={'capacity_mode':{'throughput_mode': 'PAY_PER_REQUEST'}};
```
1. È possibile utilizzare la seguente istruzione per confermare la modalità di capacità della tabella.
```
SELECT * from system_schema_mcs.tables where keyspace_name = 'catalog' and table_name = 'book_awards';
```
Una tabella configurata con la modalità di capacità su richiesta restituisce quanto segue.
```
{
"capacity_mode":{
"last_update_to_pay_per_request_timestamp":"1727952499092",
"throughput_mode":"PAY_PER_REQUEST"
}
}
```
Il `last_update_to_pay_per_request_timestamp` valore viene misurato in millisecondi.
------
#### [ CLI ]
**Modificate la modalità di capacità di trasmissione di una tabella utilizzando il AWS CLI**
1. Per modificare la modalità di capacità della tabella, è `PROVIOSIONED` necessario configurare le unità di capacità di lettura e scrittura in base ai valori di picco previsti del carico di lavoro. Il comando seguente ne è un esempio. È inoltre possibile eseguire questo comando per regolare la capacità di lettura o le unità di capacità di scrittura della tabella.
```
aws keyspaces update-table --keyspace-name catalog --table-name book_awards
\--capacity-specification throughputMode=PROVISIONED,readCapacityUnits=6000,writeCapacityUnits=3000
```
Per configurare la modalità di capacità fornita con auto-scaling, vedere. [Configura il ridimensionamento automatico su una tabella esistente](autoscaling.configureTable.md)
1. Per modificare la modalità di capacità di una tabella in modalità on demand, è necessario impostare la modalità di throughput su. `PAY_PER_REQUEST` La seguente dichiarazione ne è un esempio.
```
aws keyspaces update-table --keyspace-name catalog --table-name book_awards
\--capacity-specification throughputMode=PAY_PER_REQUEST
```
1. È possibile utilizzare il comando seguente per esaminare la modalità di capacità configurata per una tabella.
```
aws keyspaces get-table --keyspace-name catalog --table-name book_awards
```
L'output di una tabella in modalità su richiesta ha il seguente aspetto.
```
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST",
"lastUpdateToPayPerRequestTimestamp": "2024-10-03T10:48:19.092000+00:00"
}
```
------
# Configurazione del preriscaldamento per le tabelle in Amazon Keyspaces
Amazon Keyspaces ridimensiona automaticamente le partizioni di storage in base al throughput on-demand o assegnato, ma per nuove tabelle o picchi improvvisi di throughput, l'allocazione delle partizioni di storage richieste può richiedere più tempo. **Per garantire che una tabella nuova o esistente abbia una capacità sufficiente per supportare il picco di throughput previsto, puoi impostare manualmente valori di throughput a caldo specifici per preriscaldare la tabella.**
Il *throughput caldo* si riferisce al numero di operazioni di lettura e scrittura che la tabella Amazon Keyspaces può supportare istantaneamente. Questi valori sono disponibili di default per tutte le tabelle nuove ed esistenti. Se utilizzi la modalità on-demand o se aggiorni il throughput assegnato, Amazon Keyspaces garantisce che l'applicazione sia in grado di emettere richieste fino a tali valori all'istante.
Amazon Keyspaces regola automaticamente i valori di throughput a caldo all'aumentare dell'utilizzo. Per regolare la capacità di throughput in vista dei prossimi eventi di picco, ad esempio durante la migrazione di dati da un altro database, il che potrebbe richiedere il caricamento di terabyte di dati in un breve periodo di tempo, puoi aumentare manualmente i valori di throughput a caldo delle tabelle. Ciò è utile per gli eventi di picco pianificati in cui i tassi di richiesta potrebbero aumentare di 10, 100 volte o più. Innanzitutto, valuta se l'attuale throughput a caldo è sufficiente per gestire il traffico previsto. [Quindi, se è necessario preriscaldare la tabella per il carico di lavoro di picco pianificato, è possibile aumentare manualmente il valore della produttività a caldo senza modificare le impostazioni di produttività o la modalità di capacità.](ReadWriteCapacityMode.md)
È possibile preriscaldare le tabelle per operazioni di lettura, scrittura o entrambe. È possibile aumentare questo valore per tabelle a regione singola e tabelle multiregione nuove ed esistenti e le impostazioni di throughput caldo impostate si applicano automaticamente a tutte le repliche delle tabelle con più regioni. Non c'è limite al numero di tabelle Amazon Keyspaces che puoi preriscaldare in qualsiasi momento. Il tempo necessario per completare il preriscaldamento dipende dai valori impostati e dalle dimensioni della tabella. È possibile inviare richieste di preriscaldamento simultanee e tali richieste non interferiscono con le operazioni della tabella. Puoi preriscaldare il tavolo fino al limite di quota consentito dal tuo account in quella regione. Usa la [console Service Quotas](https://console.aws.amazon.com/servicequotas) per controllare le quote attuali e aumentarle se necessario.
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. Tuttavia, se aumenti manualmente i valori di throughput caldo predefiniti in tabelle preriscaldate per gli eventi di picco di traffico, si applicano costi aggiuntivi. Per ulteriori informazioni, consulta i prezzi di [Amazon Keyspaces](https://aws.amazon.com/keyspaces/pricing/).
Ecco alcuni scenari e best practice diversi da prendere in considerazione per il preriscaldamento delle tabelle Amazon Keyspaces.
## Throughput a caldo e modelli di accesso irregolari
Una tabella può avere una velocità effettiva di 30.000 unità di lettura al secondo e 10.000 unità di scrittura al secondo, ma prima di raggiungere tali valori è comunque possibile che la capacità superi gli eventi in lettura o scrittura. Ciò è probabilmente dovuto a una partizione calda. Sebbene Amazon Keyspaces possa continuare a scalare per supportare un throughput praticamente illimitato, ogni singola partizione è limitata a 1.000 unità di scrittura al secondo e 3.000 unità di lettura al secondo. Se l'applicazione indirizza troppo traffico verso una piccola parte delle partizioni della tabella, è possibile che si verifichi un superamento della capacità anche prima di raggiungere i valori di throughput ottimali della tabella. Ti consigliamo di seguire le [best practice di Amazon Keyspaces](bp-partition-key-design.md) per garantire una scalabilità perfetta ed evitare partizioni calde.
## Throughput a caldo per una tabella con provisioning
Si consideri una tabella predisposta con un throughput a caldo di 30.000 unità di lettura al secondo e 10.000 unità di scrittura al secondo, ma che attualmente ha un throughput assegnato di 4.000 e 8.000. RCUs WCUs È possibile scalare istantaneamente la velocità effettiva assegnata alla tabella fino a RCUs 30.000 o 10.000 aggiornando le impostazioni del throughput assegnato. WCUs Quando si aumenta il throughput assegnato oltre questi valori, il throughput a caldo si adatta automaticamente ai nuovi valori più alti, poiché è stato stabilito un nuovo throughput di picco. Ad esempio, se si imposta la velocità effettiva assegnata su 50.000 RCU, la velocità effettiva a caldo aumenta a 50.000 unità di lettura al secondo.
```
"ProvisionedThroughput":
{
"ReadCapacityUnits": 4000,
"WriteCapacityUnits": 8000
}
"WarmThroughput":
{
"ReadUnitsPerSecond": 30000,
"WriteUnitsPerSecond": 10000
}
```
## Throughput a caldo per una tabella on demand
Una nuova tabella on demand inizia con un throughput a caldo di 12.000 unità di lettura al secondo e 4.000 unità di scrittura al secondo. La tabella può supportare in modo istantaneo un traffico sostenuto fino a questi livelli. Quando le richieste superano le 12.000 unità di lettura al secondo o le 4.000 unità di scrittura al secondo, la velocità effettiva a caldo si adatta automaticamente ai valori più alti.
```
"WarmThroughput":
{
"ReadUnitsPerSecond": 12000,
"WriteUnitsPerSecond": 4000
}
```
## Best practice per preriscaldare le tabelle Amazon Keyspaces
Segui queste best practice per implementare il preriscaldamento per le tabelle Amazon Keyspaces:
Stima con precisione la capacità richiesta
Poiché il preriscaldamento comporta un costo una tantum, calcola attentamente la velocità effettiva necessaria in base al carico di lavoro previsto per evitare un eccessivo approvvigionamento.
Considerate lo schema della tabella
Le tabelle con righe più grandi possono richiedere più partizioni per lo stesso throughput. Nella stima del fabbisogno di preriscaldamento, tenete conto della dimensione media delle righe.
Monitora le prestazioni della tabella
Dopo il preriscaldamento, utilizza CloudWatch le metriche per verificare che la tabella gestisca il carico come previsto. Per ulteriori informazioni, consulta [Monitora le prestazioni di un tavolo preriscaldato utilizzando Amazon CloudWatch](monitor-prewarming-cloudwatch.md).
Gestisci le quote
Se l'applicazione richiede un throughput superiore a quello consentito dalle quote predefinite (40.000 RCUs/WCUs o 2.000 partizioni), la quota di richiesta aumenta con largo anticipo rispetto all'evento ad alto traffico. Per richiedere un aumento di una quota, è possibile utilizzare la [console Service Quotas](https://console.aws.amazon.com/servicequotas).
Ottimizza i costi
Per gli eventi temporanei ad alto traffico, prendi in considerazione l'utilizzo del preriscaldamento anziché passare alla modalità di approvvigionamento ad alta capacità, poiché potrebbe essere più conveniente per gli eventi di breve durata. Per ulteriori informazioni sui prezzi, consulta i prezzi di [Amazon Keyspaces](https://aws.amazon.com/keyspaces/pricing/).
**Nota**
Monitora i parametri prestazionali dell'applicazione durante la fase di test per verificare che la configurazione di preriscaldamento supporti adeguatamente i requisiti del carico di lavoro.
**Topics**
+ [Throughput a caldo e modelli di accesso irregolari](#warm-throughput-scenarios-uneven)
+ [Throughput a caldo per una tabella con provisioning](#warm-throughput-scenarios-provisioned)
+ [Throughput a caldo per una tabella on demand](#warm-throughput-scenarios-ondemand)
+ [Best practice per preriscaldare le tabelle Amazon Keyspaces](#prewarming-best-practices)
+ [Creazione di una nuova tabella Amazon Keyspaces con throughput a caldo più elevato](create-table-warm-throughput.md)
+ [Aumento del throughput a caldo di una tabella Amazon Keyspaces esistente](update-warm-throughput.md)
+ [Visualizza la velocità effettiva effettiva di una tabella Amazon Keyspaces](view-warm-throughput.md)
+ [Monitora le prestazioni di un tavolo preriscaldato utilizzando Amazon CloudWatch](monitor-prewarming-cloudwatch.md)
# Creazione di una nuova tabella Amazon Keyspaces con throughput a caldo più elevato
Puoi regolare i valori di throughput caldo quando crei la tabella Amazon Keyspaces utilizzando la console, CQL o il. AWS CLI
------
#### [ Console ]
**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/.](https://console.aws.amazon.com/keyspaces/home)
1. Nel pannello di navigazione, scegli **Tabelle**, quindi seleziona **Crea tabella**.
1. **Nella pagina Crea tabella**, nella sezione **Dettagli della tabella**, seleziona un keyspace e fornisci un nome per la nuova tabella.
1. Nella sezione **Colonne**, crea lo schema per la tua tabella.
1. Nella sezione **Chiave primaria**, definisci la chiave primaria della tabella e seleziona le colonne di clustering opzionali.
1. Nella sezione **Impostazioni tabella**, scegli **Personalizza impostazioni**.
1. Continua con le impostazioni della **capacità di lettura/scrittura**.
1. **Per la **modalità Capacity**, è possibile scegliere **On-demand o Provisioned**.**
1. 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.
1. Configura altre funzionalità opzionali della tabella in base alle esigenze. Quindi scegli **Crea tabella**.
------
#### [ Cassandra Query Language (CQL) ]
+ 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](view-warm-throughput.md)
------
#### [ CLI ]
1. Create una tabella con una produttività a caldo utilizzando uno dei seguenti metodi utilizzando il 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
```
1. 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, vedere[Visualizza la velocità effettiva effettiva di una tabella Amazon Keyspaces](view-warm-throughput.md).
------
#### [ Java ]
**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 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 partitionKeys = Arrays.asList(
PartitionKey.builder().name("year").build(),
PartitionKey.builder().name("award").build()
);
List 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());
}
}
```
------
# Aumento del throughput a caldo di una tabella Amazon Keyspaces esistente
Puoi aumentare gli attuali valori di throughput caldo della tua tabella Amazon Keyspaces utilizzando la console, CQL o il. AWS CLI
------
#### [ Console ]
**Come aumentare le impostazioni di preriscaldamento di un tavolo utilizzando la console**
1. [Accedi a e apri Console di gestione AWS la console Amazon Keyspaces a casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. Nel pannello di navigazione, scegli **Tabelle**, quindi scegli la tabella che desideri aggiornare.
1. Nella scheda **Capacità** della tabella, continua con **Preriscaldamento per i tavoli**.
1. **Nella sezione **Preriscaldamento dei tavoli**, scegli Modifica.**
1. Nella pagina **Modifica preriscaldamento per le tabelle**, puoi aggiornare i valori per Unità di **lettura al secondo e per Unità** di **scrittura al** secondo.
1. Scegli **Save changes** (Salva modifiche). La tabella viene aggiornata con le impostazioni di preriscaldamento specificate.
------
#### [ Cassandra Query Language (CQL) ]
**Aumenta le impostazioni della potenza di riscaldamento di una tabella utilizzando CQL**
+ Utilizzate l'`ALTER TABLE`istruzione per aumentare la produttività a caldo di una tabella. La seguente dichiarazione ne è un esempio.
```
ALTER TABLE catalog.book_awards
WITH CUSTOM_PROPERTIES = {
'warm_throughput': {
'read_units_per_second': 60000,
'write_units_per_second': 30000
}
};
```
Per confermare le impostazioni di capacità aggiornate della tabella, vedere[Visualizza la velocità effettiva effettiva di una tabella Amazon Keyspaces](view-warm-throughput.md).
------
#### [ CLI ]
**Aumentare le impostazioni di preriscaldamento di un tavolo utilizzando il AWS CLI**
+ Per aumentare la produttività a caldo della tabella, è possibile utilizzare il comando. `update-table` La seguente dichiarazione ne è un esempio.
```
aws keyspaces update-table \
--keyspace-name 'catalog' \
--table-name 'book_awards' \
--warmThroughputSpecification readUnitsPerSecond=60000,writeUnitsPerSecond=30000
```
Per confermare le impostazioni di capacità aggiornate della tabella, vedere[Visualizza la velocità effettiva effettiva di una tabella Amazon Keyspaces](view-warm-throughput.md).
------
#### [ Java ]
**Aggiorna le impostazioni di preriscaldamento di una tabella utilizzando l'SDK for Java.**
+ Aggiorna le impostazioni del warm-throughput per una 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 UpdatePreWarmingExample {
public static void main(String[] args) {
KeyspacesClient keyspacesClient = KeyspacesClient.builder().build();
// Define new warm throughput specification
WarmThroughputSpecification warmThroughput = WarmThroughputSpecification.builder()
.readUnitsPerSecond(60000L)
.writeUnitsPerSecond(30000L)
.build();
// Update table with new PreWarming settings
UpdateTableRequest request = UpdateTableRequest.builder()
.keyspaceName("catalog")
.tableName("book_awards")
.warmThroughputSpecification(warmThroughput)
.build();
UpdateTableResponse response = keyspacesClient.updateTable(request);
System.out.println("Table update requested: " + response.resourceArn());
}
}
```
------
# Visualizza la velocità effettiva effettiva di una tabella Amazon Keyspaces
Puoi visualizzare gli attuali valori di throughput caldo della tabella Amazon Keyspaces utilizzando la console, CQL o il. AWS CLI
------
#### [ Console ]
**Come visualizzare le impostazioni di preriscaldamento del tavolo utilizzando la console.**
1. [Accedi a e apri Console di gestione AWS la console Amazon Keyspaces a casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. Nel pannello di navigazione, scegli **Tabelle**, quindi scegli la tabella che desideri esaminare.
1. Nella scheda **Capacità** della tabella, continua con **Preriscaldamento per i tavoli**.
------
#### [ Cassandra Query Language (CQL) ]
**Visualizza le impostazioni del rendimento a caldo di una tabella utilizzando CQL**
+ Per visualizzare le impostazioni del warm-throughput di una tabella, è possibile utilizzare la seguente istruzione CQL.
```
SELECT custom_properties
FROM system_schema_mcs.tables
WHERE keyspace_name='catalog' and table_name='book_awards';
// Output:
...
custom_properties
----------------------------------------------------------------------------------
{
'warm_throughput':
{
'read_units_per_second': '40000',
'write_units_per_second': '20000',
'status': 'AVAILABLE'
}
}
...
```
------
#### [ CLI ]
**Visualizzate le impostazioni del warm-throughput di una tabella utilizzando il AWS CLI**
+ È possibile visualizzare le impostazioni del warm-throughput di una tabella utilizzando il `get-table` comando, come illustrato nell'esempio seguente.
```
aws keyspaces get-table \
--keyspace-name 'catalog' \
--table-name 'book_awards'
```
Di seguito viene illustrato l'output di esempio del `get-table` comando per una tabella a regione singola in modalità provisioning.
```
{
"keyspaceName": "catalog",
"tableName": "book_awards",
... Existing Fields ...,
"capacitySpecificationSummary": {
"throughputMode": "PROVISIONED",
"readCapacityUnits": 20000,
"writeCapacityUnits": 10000
},
"warmThroughputSpecificationSummary": {
"readUnitsPerSecond": 40000,
"writeUnitsPerSecond": 20000,
"status": "AVAILABLE"
}
}
```
Di seguito viene illustrato l'output di esempio per una tabella a regione singola in modalità on-demand.
```
{
"keyspaceName": "catalog",
"tableName": "book_awards_ondemand",
... Existing Fields ...,
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST"
},
"warmThroughputSpecificationSummary": {
"readUnitsPerSecond": 40000,
"writeUnitsPerSecond": 20000,
"status": "AVAILABLE"
}
}
```
------
#### [ Java ]
**Leggi le impostazioni di preriscaldamento di una tabella utilizzando l'SDK for Java.**
+ Leggi i valori di throughput a caldo di una tabella utilizzando. `get-table` Il seguente esempio di codice ne è un esempio.
```
import software.amazon.awssdk.services.keyspaces.KeyspacesClient;
import software.amazon.awssdk.services.keyspaces.model.*;
public class GetTableWithPreWarmingExample {
public static void main(String[] args) {
KeyspacesClient keyspacesClient = KeyspacesClient.builder().build();
// Get table details including PreWarming specification
GetTableRequest request = GetTableRequest.builder()
.keyspaceName("catalog")
.tableName("book_awards")
.build();
GetTableResponse response = keyspacesClient.getTable(request);
// Access PreWarming details
if (response.warmThroughputSpecification() != null) {
WarmThroughputSpecificationSummary warmThroughputSummary = response.warmThroughputSpecification();
System.out.println("PreWarming Status: " + warmThroughputSummary.status());
System.out.println("Read Units: " + warmThroughputSummary.readUnitsPerSecond());
System.out.println("Write Units: " + warmThroughputSummary.writeUnitsPerSecond());
// Check if PreWarming is active
if (warmThroughputSummary.status().equals("AVAILABLE")) {
System.out.println("Table is fully pre-warmed and ready for high throughput");
} else if (warmThroughputSummary.status().equals("UPDATING")) {
System.out.println("Table PreWarming is currently being updated");
}
} else {
System.out.println("Table does not have PreWarming enabled");
}
}
}
```
------
# Monitora le prestazioni di un tavolo preriscaldato utilizzando Amazon CloudWatch
Il preriscaldamento di Amazon Keyspaces non introduce nuove CloudWatch metriche, ma puoi monitorare le prestazioni delle tabelle preriscaldate utilizzando i parametri Amazon Keyspaces esistenti:
SuccessfulRequestLatency
Monitora questa metrica per verificare che la tabella preriscaldata gestisca le richieste con la latenza prevista.
WriteThrottleEvents e ReadThrottleEvents
Queste metriche dovrebbero rimanere basse per una tabella preriscaldata correttamente. Se si riscontrano errori di capacità insufficiente nonostante il preriscaldamento, potrebbe essere necessario modificare i valori della produttività a caldo.
ConsumedReadCapacityUnits e ConsumedWriteCapacityUnits
Queste metriche mostrano il consumo effettivo di capacità, il che può aiutare a verificare se la configurazione di preriscaldamento è appropriata.
ProvisionedReadCapacityUnits e ProvisionedWriteCapacityUnits
Per le tabelle predisposte, queste metriche mostrano la capacità attualmente allocata.
Queste metriche possono essere visualizzate nella CloudWatch console o interrogate utilizzando l'API. CloudWatch Per ulteriori informazioni, consulta [Monitoraggio di Amazon Keyspaces con Amazon CloudWatch](monitoring-cloudwatch.md).
# Gestisci automaticamente la capacità di throughput con la scalabilità automatica di Amazon Keyspaces
Molti carichi di lavoro dei database sono ciclici per natura o sono difficili da prevedere in anticipo. Ad esempio, considera un'app di social network in cui la maggior parte degli utenti sono attivi durante le ore diurne. Il database deve essere in grado di gestire l'attività diurna e ciò non è necessario per gli stessi livelli di throughput durante la notte.
Un altro esempio potrebbe essere una nuova app di gioco per dispositivi mobili che sta registrando una nuova adozione. Se il gioco diventasse molto popolare, potrebbe superare le risorse di database disponibili, con conseguente rallentamento delle prestazioni e insoddisfazione dei clienti. Questi tipi di carichi di lavoro richiedono spesso l'intervento manuale per aumentare o diminuire le risorse di database in risposta alla variazione dei livelli di utilizzo.
Amazon Keyspaces (per Apache Cassandra) ti aiuta a fornire la capacità di throughput in modo efficiente per carichi di lavoro variabili regolando automaticamente la capacità di throughput in risposta al traffico effettivo delle applicazioni. Amazon Keyspaces utilizza il servizio Application Auto Scaling per aumentare e diminuire la capacità di lettura e scrittura di una tabella per tuo conto. Per ulteriori informazioni su Application Auto Scaling, consultate la [Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/) User Guide.
**Nota**
Per iniziare rapidamente a usare la scalabilità automatica di Amazon Keyspaces, consulta. [Configura e aggiorna le politiche di scalabilità automatica di Amazon Keyspaces](autoscaling.configure.md)
## Come funziona il ridimensionamento automatico di Amazon Keyspaces
Il diagramma seguente fornisce una panoramica di alto livello di come il ridimensionamento automatico di Amazon Keyspaces gestisce la capacità di throughput per una tabella.
![\[Un diagramma che mostra i diversi servizi coinvolti quando un utente apporta una modifica a una tabella Amazon Keyspaces. I servizi sono Amazon CloudWatch, Amazon SNS e Application Auto Scaling, che emette l'istruzione ALTER TABLE per modificare la capacità in base all'utilizzo di lettura o scrittura degli utenti.\]](http://docs.aws.amazon.com/it_it/keyspaces/latest/devguide/images/keyspaces_auto-scaling.png)
*Per abilitare il ridimensionamento automatico per una tabella, crei una politica di ridimensionamento.* La policy di dimensionamento specifica se si desidera dimensionare la capacità di lettura o di scrittura (o entrambe) e indica le impostazioni delle unità di capacità assegnate minime e massime per la tabella.
*La politica di scalabilità definisce anche un utilizzo target.* L’utilizzo di destinazione è la proporzione tra le unità di capacità utilizzate e le unità di capacità assegnate, espressa come percentuale. Il ridimensionamento automatico utilizza un algoritmo di *tracciamento del target* per regolare il throughput assegnato della tabella verso l'alto o verso il basso in risposta ai carichi di lavoro effettivi. Lo fa in modo che l'utilizzo effettivo della capacità rimanga pari o vicino all'utilizzo previsto.
È possibile impostare i valori di utilizzo target di scalabilità automatica tra il 20 e il 90 percento per la capacità di lettura e scrittura. Il tasso di utilizzo target predefinito è del 70 percento. È possibile impostare l'utilizzo target su una percentuale inferiore se il traffico cambia rapidamente e si desidera che la capacità inizi a crescere prima. È inoltre possibile impostare il tasso di utilizzo target su un tasso più elevato se il traffico delle applicazioni cambia più lentamente e si desidera ridurre il costo del throughput.
Per ulteriori informazioni sulle politiche di scalabilità, consulta [Target tracking scaling policy for Application Auto Scaling nella Application Auto](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) Scaling [https://docs.aws.amazon.com/autoscaling/application/userguide/](https://docs.aws.amazon.com/autoscaling/application/userguide/).
Quando crei una politica di scalabilità, Amazon Keyspaces crea due coppie di allarmi CloudWatch Amazon per tuo conto. Ogni coppia rappresenta i limiti superiore e inferiore per le impostazioni di throughput assegnate e consumate. Questi CloudWatch allarmi vengono attivati quando l'utilizzo effettivo della tabella si discosta dall'utilizzo previsto per un periodo di tempo prolungato. Per ulteriori informazioni su Amazon CloudWatch, consulta la [Amazon CloudWatch User Guide](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).
Quando viene attivato uno degli CloudWatch allarmi, Amazon Simple Notification Service (Amazon SNS) ti invia una notifica (se l'hai abilitata). L' CloudWatch allarme richiama quindi Application Auto Scaling per valutare la politica di scalabilità. Questo a sua volta invia una richiesta Alter Table ad Amazon Keyspaces per aumentare o diminuire la capacità fornita della tabella, a seconda dei casi. Per ulteriori informazioni sulle notifiche di Amazon SNS, consulta [Configurazione delle notifiche Amazon SNS](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/US_SetupSNS.html).
Amazon Keyspaces elabora la richiesta Alter Table aumentando (o diminuendo) la capacità di throughput assegnata alla tabella in modo che si avvicini all'utilizzo previsto.
**Nota**
La scalabilità automatica di Amazon Keyspaces modifica le impostazioni di throughput assegnate solo quando il carico di lavoro effettivo rimane elevato (o ridotto) per un periodo prolungato di diversi minuti. L'algoritmo di monitoraggio obiettivi di cerca di tenere l'utilizzo di destinazione pari o vicino al valore scelto a lungo termine. I picchi di attività improvvisi e di breve durata sono soddisfatti dalla capacità di ottimizzazione integrata della tabella.
## Come funziona la scalabilità automatica per le tabelle multiregionali
Per garantire che ci sia sempre una capacità di lettura e scrittura sufficiente per tutte le repliche di tabella in una tabella multiregionale in modalità Regioni AWS di capacità fornita, ti consigliamo di configurare la scalabilità automatica di Amazon Keyspaces.
Quando si utilizza una tabella multiarea in modalità provisioning con ridimensionamento automatico, non è possibile disabilitare il ridimensionamento automatico per una singola replica di tabella. Ma puoi regolare le impostazioni di ridimensionamento automatico di lettura della tabella per diverse regioni. Ad esempio, è possibile specificare diverse impostazioni di capacità di lettura e di ridimensionamento automatico di lettura per ogni regione in cui viene replicata la tabella.
Le impostazioni di lettura automatica configurate per una replica di tabella in una regione specificata sovrascrivono le impostazioni generali di ridimensionamento automatico della tabella. La capacità di scrittura, tuttavia, deve rimanere sincronizzata su tutte le repliche delle tabelle per garantire una capacità sufficiente per replicare le scritture in tutte le regioni.
La scalabilità automatica di Amazon Keyspaces aggiorna in modo indipendente la capacità fornita della tabella in ciascuna regione in Regione AWS base all'utilizzo in quella regione. Di conseguenza, la capacità fornita in ciascuna regione per una tabella multiarea potrebbe essere diversa quando la scalabilità automatica è attiva.
Puoi configurare le impostazioni di ridimensionamento automatico di una tabella multiregionale e delle relative repliche utilizzando la console Amazon Keyspaces, l'API o CQL. AWS CLI Per ulteriori informazioni su come creare e aggiornare le impostazioni di ridimensionamento automatico per le tabelle multiregionali, vedere. [Aggiorna la capacità fornita e le impostazioni di ridimensionamento automatico per una tabella multiregionale in Amazon Keyspaces](tables-mrr-autoscaling.md)
**Nota**
Se utilizzi la scalabilità automatica per tabelle multiregionali, devi sempre utilizzare le operazioni dell'API Amazon Keyspaces per configurare le impostazioni di auto scaling. Se utilizzi direttamente le operazioni dell'API Application Auto Scaling per configurare le impostazioni di auto scaling, non hai la possibilità Regioni AWS di specificare la tabella Multi-regione. Ciò può comportare configurazioni non supportate.
## Note per l’utilizzo
Prima di iniziare a utilizzare il ridimensionamento automatico di Amazon Keyspaces, è necessario tenere presente quanto segue:
+ Il ridimensionamento automatico di Amazon Keyspaces non è disponibile nella regione del Medio Oriente (Emirati Arabi Uniti).
+ La scalabilità automatica di Amazon Keyspaces può aumentare la capacità di lettura o scrittura ogni volta che è necessario, in conformità con la tua politica di scalabilità. Tutte le quote di Amazon Keyspaces rimangono in vigore, come descritto in. [Quote per Amazon Keyspaces (per Apache Cassandra)](quotas.md)
+ Il ridimensionamento automatico di Amazon Keyspaces non impedisce di modificare manualmente le impostazioni di throughput assegnate. Queste regolazioni manuali non influiscono sugli CloudWatch allarmi esistenti associati alla politica di scalabilità.
+ Se utilizzi la console per creare una tabella con capacità di throughput assegnata, la scalabilità automatica di Amazon Keyspaces è abilitata per impostazione predefinita. Puoi modificare le impostazioni di ridimensionamento automatico in qualsiasi momento. Per ulteriori informazioni, consulta [Disattiva la scalabilità automatica di Amazon Keyspaces per una tabella](autoscaling.turnoff.md).
+ Se utilizzi CloudFormation per creare policy di scalabilità, dovresti gestire le policy di scalabilità in CloudFormation modo che lo stack sia sincronizzato con il modello di stack. Se modifichi le politiche di scalabilità da Amazon Keyspaces, queste verranno sovrascritte con i valori originali del modello di stack quando CloudFormation lo stack viene reimpostato.
+ Se utilizzi CloudTrail per monitorare la scalabilità automatica di Amazon Keyspaces, potresti ricevere avvisi per le chiamate effettuate da Application Auto Scaling come parte del processo di convalida della configurazione. Puoi filtrare questi avvisi utilizzando il `invokedBy` campo che contiene questi controlli di convalida. `application-autoscaling.amazonaws.com`
# Configura e aggiorna le politiche di scalabilità automatica di Amazon Keyspaces
Puoi utilizzare la console, CQL o AWS Command Line Interface (AWS CLI) per configurare la scalabilità automatica di Amazon Keyspaces per tabelle nuove ed esistenti. Puoi anche modificare le impostazioni di ridimensionamento automatico o disabilitare il ridimensionamento automatico.
Per funzionalità più avanzate come l'impostazione dei tempi di cooldown scale-in e scale-out, ti consigliamo di utilizzare CQL o il per gestire le politiche di scalabilità di AWS CLI Amazon Keyspaces.
**Topics**
+ [Configura le autorizzazioni per la scalabilità automatica di Amazon Keyspaces](autoscaling.permissions.md)
+ [Crea una nuova tabella con ridimensionamento automatico](autoscaling.createTable.md)
+ [Configura il ridimensionamento automatico su una tabella esistente](autoscaling.configureTable.md)
+ [Visualizza la configurazione di scalabilità automatica di Amazon Keyspaces della tua tabella](autoscaling.viewPolicy.md)
+ [Disattiva la scalabilità automatica di Amazon Keyspaces per una tabella](autoscaling.turnoff.md)
+ [Visualizza l'attività di scalabilità automatica per una tabella Amazon Keyspaces in Amazon CloudWatch](autoscaling.activity.md)
# Configura le autorizzazioni per la scalabilità automatica di Amazon Keyspaces
Per iniziare, verifica che il responsabile disponga delle autorizzazioni appropriate per creare e gestire le impostazioni di ridimensionamento automatico. In AWS Identity and Access Management (IAM), la policy AWS gestita `AmazonKeyspacesFullAccess` è necessaria per gestire le policy di scalabilità di Amazon Keyspaces.
**Importante**
`application-autoscaling:*`sono necessarie autorizzazioni per disabilitare il ridimensionamento automatico su una tabella. È necessario disattivare il ridimensionamento automatico per una tabella prima di poterla eliminare.
Per configurare un utente o un ruolo IAM per l'accesso alla console Amazon Keyspaces e la scalabilità automatica di Amazon Keyspaces, aggiungi la seguente policy.
**Per allegare la policy `AmazonKeyspacesFullAccess`**
1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nella dashboard della console IAM, scegli **Utenti**, quindi scegli il tuo utente o ruolo IAM dall'elenco.
1. Nella pagina **Summary (Riepilogo)**, scegli **Add permissions (Aggiungi autorizzazioni)**.
1. Scegli **Attach existing policies directly (Collega direttamente le policy esistenti)**.
1. Dall'elenco delle politiche, scegli **AmazonKeyspacesFullAccess**, quindi scegli **Avanti: revisione**.
1. Scegli **Add Permissions (Aggiungi autorizzazioni)**.
# Crea una nuova tabella con ridimensionamento automatico
Quando crei una nuova tabella Amazon Keyspaces, puoi abilitare automaticamente la scalabilità automatica per la capacità di scrittura o lettura della tabella. Ciò consente ad Amazon Keyspaces di contattare Application Auto Scaling per tuo conto per registrare la tabella come destinazione scalabile e regolare la capacità di scrittura o lettura fornita.
Per ulteriori informazioni su come creare una tabella multiregionale e configurare diverse impostazioni di ridimensionamento automatico per le repliche di tabelle, vedere. [Crea una tabella multiregionale in modalità provisioning con scalabilità automatica in Amazon Keyspaces](tables-mrr-create-provisioned.md)
**Nota**
La scalabilità automatica di Amazon Keyspaces richiede la presenza di un ruolo collegato al servizio (`AWSServiceRoleForApplicationAutoScaling_CassandraTable`) che esegue azioni di ridimensionamento automatico per tuo conto. Questo ruolo viene creato automaticamente per te. Per ulteriori informazioni, consulta [Utilizzo di ruoli collegati ai servizi per Amazon Keyspaces](using-service-linked-roles.md).
------
#### [ Console ]
**Crea una nuova tabella con ridimensionamento automatico abilitato utilizzando la console**
1. [Accedi a e apri Console di gestione AWS la console Amazon Keyspaces a casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. Nel pannello di navigazione, scegli **Tabelle**, quindi seleziona **Crea tabella**.
1. **Nella pagina Crea tabella**, nella sezione **Dettagli della tabella**, seleziona un keyspace e fornisci un nome per la nuova tabella.
1. Nella sezione **Colonne**, crea lo schema per la tua tabella.
1. Nella sezione **Chiave primaria**, definisci la chiave primaria della tabella e seleziona le colonne di clustering opzionali.
1. Nella sezione **Impostazioni tabella**, scegli **Personalizza impostazioni**.
1. Continua con le impostazioni della **capacità di lettura/scrittura**.
1. **Per la **modalità Capacity**, scegli Provisioned.**
1. Nella sezione **Capacità di lettura**, conferma che l'opzione **Scale automaticamente** sia selezionata.
In questo passaggio, si selezionano le unità di capacità di lettura minima e massima per la tabella, nonché l'utilizzo previsto.
+ **Unità di capacità minima**: immettete il valore per il livello minimo di velocità effettiva che la tabella deve essere sempre pronta a supportare. Il valore deve essere compreso tra 1 e la quota massima di throughput al secondo prevista per l'account (40.000 per impostazione predefinita).
+ **Unità di capacità massima**: inserisci la quantità massima di velocità effettiva che desideri fornire per la tabella. Il valore deve essere compreso tra 1 e la quota massima di throughput al secondo prevista per l'account (40.000 per impostazione predefinita).
+ **Utilizzo obiettivo**: inserisci un tasso di utilizzo obiettivo compreso tra il 20% e il 90%. Quando il traffico supera il tasso di utilizzo target definito, la capacità viene automaticamente aumentata. Quando il traffico scende al di sotto dell'obiettivo definito, viene nuovamente ridimensionato automaticamente.
**Nota**
Per ulteriori informazioni sulle quote predefinite per il tuo account e su come aumentarle, consulta. [Quote per Amazon Keyspaces (per Apache Cassandra)](quotas.md)
1. Nella sezione **Capacità di scrittura**, scegli le stesse impostazioni definite nel passaggio precedente per la capacità di lettura o configura i valori della capacità manualmente.
1. Scegliere **Create table (Crea tabella)**. La tabella viene creata con i parametri di ridimensionamento automatico specificati.
------
#### [ Cassandra Query Language (CQL) ]
**Crea una nuova tabella con la scalabilità automatica di Amazon Keyspaces tramite CQL**
Per configurare le impostazioni di auto scaling per una tabella a livello di codice, usi l'`AUTOSCALING_SETTINGS`istruzione che contiene i parametri per la scalabilità automatica di Amazon Keyspaces. I parametri definiscono le condizioni che spingono Amazon Keyspaces a modificare il throughput assegnato alla tabella e quali azioni opzionali aggiuntive intraprendere. In questo esempio, definisci le impostazioni di ridimensionamento automatico per *mytable*.
La policy contiene i seguenti elementi:
+ `AUTOSCALING_SETTINGS`— Indica se Amazon Keyspaces è autorizzato a modificare la capacità di throughput per tuo conto. Sono richiesti i seguenti valori:
+ `provisioned_write_capacity_autoscaling_update`:
+ `minimum_units`
+ `maximum_units`
+ `provisioned_read_capacity_autoscaling_update`:
+ `minimum_units`
+ `maximum_units`
+ `scaling_policy`— Amazon Keyspaces supporta la politica di tracciamento degli obiettivi. Per definire la politica di tracciamento degli obiettivi, configuri i seguenti parametri.
+ `target_value`— La scalabilità automatica di Amazon Keyspaces assicura che il rapporto tra capacità consumata e capacità fornita rimanga pari o vicino a questo valore. `target_value` viene definito in percentuale.
+ `disableScaleIn`: (Facoltativo) A `boolean` che specifica se `scale-in` è disabilitato o abilitato per la tabella. Questo parametro è disabilitato per impostazione predefinita. Per attivarlo`scale-in`, imposta il `boolean` valore su`FALSE`. Ciò significa che la capacità viene automaticamente ridotta per una tabella per conto dell'utente.
+ `scale_out_cooldown`— Un'attività di scalabilità orizzontale aumenta la velocità effettiva assegnata alla tabella. Per aggiungere un periodo di recupero per le attività con scalabilità orizzontale, specifica un valore, in secondi, per. `scale_out_cooldown` Se non specifichi un valore, il valore predefinito è 0. Per ulteriori informazioni sul tracciamento del target e sui periodi di cooldown, consulta [Target Tracking Scaling Policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) nella *Application Auto Scaling* User Guide.
+ `scale_in_cooldown`— Un'attività scalabile riduce il throughput assegnato alla tabella. Per aggiungere un periodo di recupero per le attività scalabili, specifica un valore, in secondi, per. `scale_in_cooldown` Se non specificate un valore, il valore predefinito è 0. Per ulteriori informazioni sul tracciamento del target e sui periodi di cooldown, consulta [Target Tracking Scaling Policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) nella *Application Auto Scaling* User Guide.
**Nota**
Per capire meglio come funziona `target_value`, supponiamo di avere una tabella con un'impostazione di velocità effettiva assegnata pari a 200 unità di capacità in scrittura. Si decide di creare una policy di dimensionamento per questa tabella, con un `target_value` del 70%.
Si supponga ora di iniziare a guidare il traffico di scrittura verso la tabella in modo che la velocità effettiva di scrittura sia di 150 unità di capacità. Il consumed-to-provisioned rapporto è ora (150/ 200), ovvero il 75 percento. Questo rapporto supera l'obiettivo, quindi la scalabilità automatica aumenta la capacità di scrittura assegnata a 215 in modo che il rapporto sia (150/ 215), ovvero il 69,77 percento, il più vicino `target_value` possibile, ma senza superarlo.
Per *mytable*, hai impostato la capacità di lettura e scrittura al `TargetValue` 50%. La scalabilità automatica di Amazon Keyspaces regola il throughput assegnato dalla tabella entro un intervallo di 5-10 unità di capacità in modo che il rapporto rimanga pari o vicino al consumed-to-provisioned 50%. Per quanto riguarda la capacità di lettura, si impostano i valori per e fino a 60 secondi. `ScaleOutCooldown` `ScaleInCooldown`
Puoi utilizzare la seguente istruzione per creare una nuova tabella Amazon Keyspaces con la scalabilità automatica abilitata.
```
CREATE TABLE mykeyspace.mytable(pk int, ck int, PRIMARY KEY (pk, ck))
WITH CUSTOM_PROPERTIES = {
'capacity_mode': {
'throughput_mode': 'PROVISIONED',
'read_capacity_units': 1,
'write_capacity_units': 1
}
} AND AUTOSCALING_SETTINGS = {
'provisioned_write_capacity_autoscaling_update': {
'maximum_units': 10,
'minimum_units': 5,
'scaling_policy': {
'target_tracking_scaling_policy_configuration': {
'target_value': 50
}
}
},
'provisioned_read_capacity_autoscaling_update': {
'maximum_units': 10,
'minimum_units': 5,
'scaling_policy': {
'target_tracking_scaling_policy_configuration': {
'target_value': 50,
'scale_in_cooldown': 60,
'scale_out_cooldown': 60
}
}
}
};
```
------
#### [ CLI ]
**Crea una nuova tabella con il ridimensionamento automatico di Amazon Keyspaces utilizzando AWS CLI**
Per configurare le impostazioni di auto scaling per una tabella a livello di codice, usi l'`autoScalingSpecification`azione che definisce i parametri per la scalabilità automatica di Amazon Keyspaces. I parametri definiscono le condizioni che spingono Amazon Keyspaces a modificare il throughput assegnato alla tabella e quali azioni opzionali aggiuntive intraprendere. In questo esempio, definisci le impostazioni di ridimensionamento automatico per *mytable*.
La policy contiene i seguenti elementi:
+ `autoScalingSpecification`— Indica se Amazon Keyspaces è autorizzato a regolare la capacità di trasmissione per tuo conto. È possibile abilitare la scalabilità automatica per la capacità di lettura e scrittura separatamente. Quindi è necessario specificare i seguenti parametri per`autoScalingSpecification`:
+ `writeCapacityAutoScaling`— Le unità con capacità di scrittura massima e minima.
+ `readCapacityAutoScaling`— Le unità con capacità di lettura massima e minima.
+ `scalingPolicy`— Amazon Keyspaces supporta la politica di tracciamento degli obiettivi. Per definire la politica di tracciamento degli obiettivi, configuri i seguenti parametri.
+ `targetValue`— La scalabilità automatica di Amazon Keyspaces assicura che il rapporto tra capacità consumata e capacità fornita rimanga pari o vicino a questo valore. `targetValue` viene definito in percentuale.
+ `disableScaleIn`: (Facoltativo) A `boolean` che specifica se `scale-in` è disabilitato o abilitato per la tabella. Questo parametro è disabilitato per impostazione predefinita. Per attivarlo`scale-in`, imposta il `boolean` valore su`FALSE`. Ciò significa che la capacità viene automaticamente ridotta per una tabella per conto dell'utente.
+ `scaleOutCooldown`— Un'attività di scalabilità orizzontale aumenta la velocità effettiva assegnata alla tabella. Per aggiungere un periodo di recupero per le attività con scalabilità orizzontale, specifica un valore, in secondi, per. `ScaleOutCooldown` Il valore predefinito è 0. Per ulteriori informazioni sul tracciamento del target e sui periodi di cooldown, consulta [Target Tracking Scaling Policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) nella *Application Auto Scaling* User Guide.
+ `scaleInCooldown`— Un'attività scalabile riduce il throughput assegnato alla tabella. Per aggiungere un periodo di recupero per le attività scalabili, specifica un valore, in secondi, per. `ScaleInCooldown` Il valore predefinito è 0. Per ulteriori informazioni sul tracciamento del target e sui periodi di cooldown, consulta [Target Tracking Scaling Policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) nella *Application Auto Scaling* User Guide.
**Nota**
Per capire meglio come funziona `TargetValue`, supponiamo di avere una tabella con un'impostazione di velocità effettiva assegnata pari a 200 unità di capacità in scrittura. Si decide di creare una policy di dimensionamento per questa tabella, con un `TargetValue` del 70%.
Si supponga ora di iniziare a guidare il traffico di scrittura verso la tabella in modo che la velocità effettiva di scrittura sia di 150 unità di capacità. Il consumed-to-provisioned rapporto è ora (150/ 200), ovvero il 75 percento. Questo rapporto supera l'obiettivo, quindi la scalabilità automatica aumenta la capacità di scrittura assegnata a 215 in modo che il rapporto sia (150/ 215), ovvero il 69,77 percento, il più vicino `TargetValue` possibile, ma senza superarlo.
Per *mytable*, hai impostato la capacità di lettura e scrittura al `TargetValue` 50%. La scalabilità automatica di Amazon Keyspaces regola il throughput assegnato dalla tabella entro un intervallo di 5-10 unità di capacità in modo che il rapporto rimanga pari o vicino al consumed-to-provisioned 50%. Per quanto riguarda la capacità di lettura, si impostano i valori per e fino a 60 secondi. `ScaleOutCooldown` `ScaleInCooldown`
Quando si creano tabelle con impostazioni di ridimensionamento automatico complesse, è utile caricare le impostazioni di ridimensionamento automatico da un file JSON. Per l'esempio seguente, puoi scaricare il file JSON di esempio da [auto-scaling.zip](samples/auto-scaling.zip) ed estrarlo`auto-scaling.json`, prendendo nota del percorso del file. In questo esempio, il file JSON si trova nella directory corrente. Per le diverse opzioni relative al percorso dei file, consultate [Come caricare i parametri da un file](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html#cli-usage-parameters-file-how).
```
aws keyspaces create-table --keyspace-name mykeyspace --table-name mytable
\ --schema-definition 'allColumns=[{name=pk,type=int},{name=ck,type=int}],partitionKeys=[{name=pk},{name=ck}]'
\ --capacity-specification throughputMode=PROVISIONED,readCapacityUnits=1,writeCapacityUnits=1
\ --auto-scaling-specification file://auto-scaling.json
```
------
# Configura il ridimensionamento automatico su una tabella esistente
Puoi aggiornare una tabella Amazon Keyspaces esistente per attivare la scalabilità automatica per la capacità di scrittura o lettura della tabella. Se stai aggiornando una tabella che è attualmente in modalità di capacità su richiesta, devi prima modificare la modalità di capacità della tabella in modalità di capacità fornita.
Per ulteriori informazioni su come aggiornare le impostazioni di ridimensionamento automatico per una tabella multiregionale, vedere. [Aggiorna la capacità fornita e le impostazioni di ridimensionamento automatico per una tabella multiregionale in Amazon Keyspaces](tables-mrr-autoscaling.md)
La scalabilità automatica di Amazon Keyspaces richiede la presenza di un ruolo collegato al servizio (`AWSServiceRoleForApplicationAutoScaling_CassandraTable`) che esegue azioni di ridimensionamento automatico per tuo conto. Questo ruolo viene creato automaticamente per te. Per ulteriori informazioni, consulta [Utilizzo di ruoli collegati ai servizi per Amazon Keyspaces](using-service-linked-roles.md).
------
#### [ Console ]
**Configura il ridimensionamento automatico di Amazon Keyspaces per una tabella esistente**
1. [Accedi a e apri Console di gestione AWS la console Amazon Keyspaces a casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. Scegli la tabella su cui vuoi lavorare e vai alla scheda **Capacità**.
1. Nella sezione **Impostazioni di capacità**, scegli **Modifica**.
1. In **modalità Capacity**, assicurati che la tabella utilizzi la modalità **Provisioned** capacity.
1. Seleziona **Scale automaticamente** e consulta il passaggio 6 [Crea una nuova tabella con ridimensionamento automatico](autoscaling.createTable.md) per modificare la capacità di lettura e scrittura.
1. Una volta definite le impostazioni di ridimensionamento automatico, scegli **Salva**.
------
#### [ Cassandra Query Language (CQL) ]
**Configura una tabella esistente con la scalabilità automatica di Amazon Keyspaces tramite CQL**
Puoi utilizzare l'`ALTER TABLE`istruzione per una tabella Amazon Keyspaces esistente per configurare la scalabilità automatica per la capacità di scrittura o lettura della tabella. Se stai aggiornando una tabella che è attualmente in modalità di capacità su richiesta, devi `capacity_mode` impostarla su provisioned. Se la tabella è già in modalità di capacità assegnata, questo campo può essere omesso.
Nell'esempio seguente, l'istruzione aggiorna la tabella *mytable*, che è in modalità di capacità su richiesta. L'istruzione modifica la modalità di capacità della tabella in modalità provisioning con la scalabilità automatica abilitata.
La capacità di scrittura è configurata nell'intervallo di 5-10 unità di capacità con un valore target del 50%. La capacità di lettura è inoltre configurata nell'intervallo di 5-10 unità di capacità con un valore obiettivo del 50%. Per la capacità di lettura, si impostano i valori per `scale_out_cooldown` e `scale_in_cooldown` fino a 60 secondi.
```
ALTER TABLE mykeyspace.mytable
WITH CUSTOM_PROPERTIES = {
'capacity_mode': {
'throughput_mode': 'PROVISIONED',
'read_capacity_units': 1,
'write_capacity_units': 1
}
} AND AUTOSCALING_SETTINGS = {
'provisioned_write_capacity_autoscaling_update': {
'maximum_units': 10,
'minimum_units': 5,
'scaling_policy': {
'target_tracking_scaling_policy_configuration': {
'target_value': 50
}
}
},
'provisioned_read_capacity_autoscaling_update': {
'maximum_units': 10,
'minimum_units': 5,
'scaling_policy': {
'target_tracking_scaling_policy_configuration': {
'target_value': 50,
'scale_in_cooldown': 60,
'scale_out_cooldown': 60
}
}
}
};
```
------
#### [ CLI ]
**Configura una tabella esistente con il ridimensionamento automatico di Amazon Keyspaces utilizzando AWS CLI**
Per una tabella Amazon Keyspaces esistente, puoi attivare la scalabilità automatica per la capacità di scrittura o lettura della tabella utilizzando l'operazione. `UpdateTable`
Puoi utilizzare il seguente comando per attivare la scalabilità automatica di Amazon Keyspaces per una tabella esistente. Le impostazioni di ridimensionamento automatico per la tabella vengono caricate da un file JSON. Per l'esempio seguente, puoi scaricare il file JSON di esempio da [auto-scaling.zip](samples/auto-scaling.zip) ed estrarlo`auto-scaling.json`, prendendo nota del percorso del file. In questo esempio, il file JSON si trova nella directory corrente. Per le diverse opzioni relative al percorso dei file, consultate [Come caricare i parametri da un file](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html#cli-usage-parameters-file-how).
Per ulteriori informazioni sulle impostazioni di ridimensionamento automatico utilizzate nell'esempio seguente, vedere[Crea una nuova tabella con ridimensionamento automatico](autoscaling.createTable.md).
```
aws keyspaces update-table --keyspace-name mykeyspace --table-name mytable
\ --capacity-specification throughputMode=PROVISIONED,readCapacityUnits=1,writeCapacityUnits=1
\ --auto-scaling-specification file://auto-scaling.json
```
------
# Visualizza la configurazione di scalabilità automatica di Amazon Keyspaces della tua tabella
Puoi utilizzare la console, CQL o il AWS CLI per visualizzare e aggiornare le impostazioni di ridimensionamento automatico di Amazon Keyspaces di una tabella.
------
#### [ Console ]
****
**Visualizza le impostazioni di ridimensionamento automatico utilizzando la console**
1. Scegli la tabella che desideri visualizzare e vai alla scheda **Capacità**.
1. Nella sezione **Impostazioni di capacità**, scegli **Modifica**. Ora puoi modificare le impostazioni nelle sezioni **Capacità di lettura** o **Capacità di scrittura**. Per ulteriori informazioni su queste impostazioni, consultare [Crea una nuova tabella con ridimensionamento automatico](autoscaling.createTable.md).
------
#### [ Cassandra Query Language (CQL) ]
**Visualizza la politica di scalabilità automatica di Amazon Keyspaces della tua tabella utilizzando CQL**
Per visualizzare i dettagli della configurazione di ridimensionamento automatico di una tabella, utilizzare il comando seguente.
```
SELECT * FROM system_schema_mcs.autoscaling WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
L'output di questo comando è simile al seguente.
```
keyspace_name | table_name | provisioned_read_capacity_autoscaling_update | provisioned_write_capacity_autoscaling_update
---------------+------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
mykeyspace | mytable | {'minimum_units': 5, 'maximum_units': 10, 'scaling_policy': {'target_tracking_scaling_policy_configuration': {'scale_out_cooldown': 60, 'disable_scale_in': false, 'target_value': 50, 'scale_in_cooldown': 60}}} | {'minimum_units': 5, 'maximum_units': 10, 'scaling_policy': {'target_tracking_scaling_policy_configuration': {'scale_out_cooldown': 0, 'disable_scale_in': false, 'target_value': 50, 'scale_in_cooldown': 0}}}
```
------
#### [ CLI ]
**Visualizza la politica di scalabilità automatica di Amazon Keyspaces della tua tabella utilizzando il AWS CLI**
Per visualizzare la configurazione di ridimensionamento automatico di una tabella, è possibile utilizzare l'`get-table-auto-scaling-settings`operazione. Il seguente comando CLI ne è un esempio.
```
aws keyspaces get-table-auto-scaling-settings --keyspace-name mykeyspace --table-name mytable
```
L'output di questo comando è simile al seguente.
```
{
"keyspaceName": "mykeyspace",
"tableName": "mytable",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable",
"autoScalingSpecification": {
"writeCapacityAutoScaling": {
"autoScalingDisabled": false,
"minimumUnits": 5,
"maximumUnits": 10,
"scalingPolicy": {
"targetTrackingScalingPolicyConfiguration": {
"disableScaleIn": false,
"scaleInCooldown": 0,
"scaleOutCooldown": 0,
"targetValue": 50.0
}
}
},
"readCapacityAutoScaling": {
"autoScalingDisabled": false,
"minimumUnits": 5,
"maximumUnits": 10,
"scalingPolicy": {
"targetTrackingScalingPolicyConfiguration": {
"disableScaleIn": false,
"scaleInCooldown": 60,
"scaleOutCooldown": 60,
"targetValue": 50.0
}
}
}
}
}
```
------
# Disattiva la scalabilità automatica di Amazon Keyspaces per una tabella
Puoi disattivare la scalabilità automatica di Amazon Keyspaces per la tua tabella in qualsiasi momento. Se non hai più bisogno di ridimensionare la capacità di lettura o scrittura della tabella, dovresti prendere in considerazione la possibilità di disattivare la scalabilità automatica in modo che Amazon Keyspaces non continui a modificare le impostazioni della capacità di lettura o scrittura della tabella. Puoi aggiornare la tabella utilizzando la console, CQL o. AWS CLI
La disattivazione del ridimensionamento automatico elimina anche gli CloudWatch allarmi creati per tuo conto.
Per eliminare il ruolo collegato al servizio utilizzato da Application Auto Scaling per accedere alla tabella Amazon Keyspaces, segui la procedura riportata di seguito. [Eliminazione di un ruolo collegato al servizio per Amazon Keyspaces](using-service-linked-roles-app-auto-scaling.md#delete-service-linked-role-app-auto-scaling)
**Nota**
Per eliminare il ruolo collegato al servizio utilizzato da Application Auto Scaling, è necessario disabilitare il ridimensionamento automatico su tutte le tabelle dell'account in tutto. Regioni AWS
------
#### [ Console ]
**Disattiva il ridimensionamento automatico di Amazon Keyspaces per la tua tabella utilizzando la console**
**Utilizzo della console Amazon Keyspaces**
1. [Accedi a e apri Console di gestione AWS la console Amazon Keyspaces a casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. Scegli la tabella che desideri aggiornare e vai alla scheda **Capacità**.
1. Nella sezione **Impostazioni di capacità**, scegli **Modifica**.
1. Per disabilitare il ridimensionamento automatico di Amazon Keyspaces, deseleziona la casella di controllo **Scala automaticamente**. La disabilitazione del ridimensionamento automatico annulla la registrazione della tabella come destinazione scalabile con Application Auto Scaling.
------
#### [ Cassandra Query Language (CQL) ]
**Disattiva il ridimensionamento automatico di Amazon Keyspaces per la tua tabella utilizzando CQL**
L'istruzione seguente disattiva la scalabilità automatica per la capacità di scrittura della tabella *mytable*.
```
ALTER TABLE mykeyspace.mytable
WITH AUTOSCALING_SETTINGS = {
'provisioned_write_capacity_autoscaling_update': {
'autoscaling_disabled': true
}
};
```
------
#### [ CLI ]
**Disattiva il ridimensionamento automatico di Amazon Keyspaces per la tua tabella utilizzando il AWS CLI**
Il comando seguente disattiva il ridimensionamento automatico per la capacità di lettura della tabella. Elimina anche gli CloudWatch allarmi che sono stati creati per tuo conto.
```
aws keyspaces update-table --keyspace-name mykeyspace --table-name mytable
\ --auto-scaling-specification readCapacityAutoScaling={autoScalingDisabled=true}
```
------
# Visualizza l'attività di scalabilità automatica per una tabella Amazon Keyspaces in Amazon CloudWatch
Puoi monitorare il modo in cui la scalabilità automatica di Amazon Keyspaces utilizza le risorse utilizzando Amazon CloudWatch, che genera metriche sull'utilizzo e sulle prestazioni. Segui i passaggi indicati nella [Guida per l'Application Auto Scaling utente](https://docs.aws.amazon.com/autoscaling/application/userguide/monitoring-cloudwatch.html) per creare una dashboard. CloudWatch
# Usa la capacità burst in modo efficace in Amazon Keyspaces
*Amazon Keyspaces offre una certa flessibilità nel provisioning del throughput per partizione fornendo capacità burst.* Ogni volta che non utilizzi appieno il throughput di una partizione, Amazon Keyspaces riserva una parte di quella capacità inutilizzata per successivi aumenti di throughput per gestire *i picchi* di utilizzo.
Amazon Keyspaces conserva attualmente fino a 5 minuti (300 secondi) di capacità di lettura e scrittura inutilizzata. Durante un'attività occasionale di lettura o scrittura, queste unità di capacità aggiuntiva possono essere consumate rapidamente, anche più velocemente della capacità di throughput al secondo prevista per la tabella.
Amazon Keyspaces può inoltre consumare capacità burst per la manutenzione in background e altre attività senza preavviso.
Tieni presente che tali dettagli della capacità di ottimizzazione in futuro potrebbero cambiare.