Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwaltung serverloser Ressourcen in Amazon Keyspaces (für Apache Cassandra)
Amazon Keyspaces (für Apache Cassandra) ist eine Serverless-Anwendung. Anstatt Speicher- und Rechenressourcen für Ihre Arbeitslast über Knoten in einem Cluster bereitzustellen, zu verwalten und zu warten, weist Amazon Keyspaces Speicher- und read/write Durchsatzressourcen direkt Tabellen zu.
Amazon Keyspaces stellt Speicherplatz automatisch auf der Grundlage der in Ihren Tabellen gespeicherten Daten bereit. Es skaliert den Speicherplatz beim Schreiben, Aktualisieren und Löschen von Daten nach oben und unten, und Sie zahlen nur für den Speicherplatz, den Sie tatsächlich nutzen. Daten werden für eine hohe Verfügbarkeit über mehrere [Availability Zones](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/) hinweg repliziert. Amazon Keyspaces überwacht kontinuierlich die Größe Ihrer Tabellen, um Ihre Speichergebühren zu ermitteln. Weitere Informationen darüber, wie Amazon Keyspaces die fakturierbare Größe der Daten berechnet, finden Sie unter. [Schätzen Sie die Zeilengröße in Amazon Keyspaces](calculating-row-size.md)
Dieses Kapitel behandelt die wichtigsten Aspekte des Ressourcenmanagements in Amazon Keyspaces.
+ **Zeilengröße schätzen** — Um die kodierte Größe von Zeilen in Amazon Keyspaces zu schätzen, berücksichtigen Sie Faktoren wie Partitionsschlüssel-Metadaten, Cluster-Spaltenmetadaten, Spaltenbezeichner, Datentypen und Zeilenmetadaten. Diese kodierte Zeilengröße wird für die Abrechnung, die Kontingentverwaltung und die Kapazitätsplanung für den bereitgestellten Durchsatz verwendet.
+ **Schätzung des Kapazitätsverbrauchs** — Dieser Abschnitt enthält Beispiele für die Schätzung des Lese- und Schreibkapazitätsverbrauchs für gängige Szenarien wie Bereichsabfragen, Grenzwertabfragen, Tabellenscans, einfache Transaktionen, statische Spalten und Tabellen mit mehreren Regionen. Sie können Amazon verwenden CloudWatch , um die tatsächliche Kapazitätsauslastung zu überwachen. Weitere Informationen zur Überwachung mit CloudWatch finden Sie unter[Überwachung von Amazon Keyspaces mit Amazon CloudWatch](monitoring-cloudwatch.md).
+ ** read/write Kapazitätsmodi konfigurieren** — Sie können zwischen zwei Kapazitätsmodi für die Verarbeitung von Lese- und Schreibvorgängen in Ihren Tabellen wählen:
+ **On-Demand-Modus (Standard)** — Bezahlung pro Anfrage für den Lese- und Schreibdurchsatz. Amazon Keyspaces kann die Kapazität sofort auf jedes zuvor erreichte Verkehrsniveau skalieren.
+ **Bereitgestellter Modus** — Geben Sie im Voraus die erforderliche Anzahl an Lese- und Schreibkapazitätseinheiten an. Dieser Modus trägt zur Aufrechterhaltung einer vorhersehbaren Durchsatzleistung bei.
+ **Verwaltung der Durchsatzkapazität mit automatischer Skalierung** — Für bereitgestellte Tabellen können Sie die automatische Skalierung aktivieren, um die Durchsatzkapazität automatisch an den tatsächlichen Anwendungsdatenverkehr anzupassen. Amazon Keyspaces verwendet Target Tracking, um die bereitgestellte Kapazität zu erhöhen oder zu verringern und die Auslastung auf Ihrem angegebenen Ziel zu halten.
+ **Effektive Nutzung von Burst-Kapazität** — Amazon Keyspaces bietet Burst-Kapazität, indem ein Teil des ungenutzten Durchsatzes für die Bewältigung von Verkehrsspitzen reserviert wird. Diese Flexibilität ermöglicht gelegentliche Aktivitätsschübe, die Ihren bereitgestellten Durchsatz übersteigen.
Informationen zur Behebung von Kapazitätsfehlern finden Sie unter. [Kapazitätsfehler bei serverlosen Servern](troubleshooting.serverless.md#troubleshooting-serverless)
**Topics**
+ [
# Schätzen Sie die Zeilengröße in Amazon Keyspaces
](calculating-row-size.md)
+ [
# Schätzen Sie den Kapazitätsverbrauch des Lese- und Schreibdurchsatzes in Amazon Keyspaces
](capacity-examples.md)
+ [
# read/write Kapazitätsmodi in Amazon Keyspaces konfigurieren
](ReadWriteCapacityMode.md)
+ [
# Automatische Verwaltung der Durchsatzkapazität mit Amazon Keyspaces Auto Scaling
](autoscaling.md)
+ [
# Effektive Nutzung von Burst-Kapazitäten in Amazon Keyspaces
](throughput-bursting.md)
# Schätzen Sie die Zeilengröße in Amazon Keyspaces
Amazon Keyspaces bietet vollständig verwalteten Speicher, der eine Lese- und Schreibleistung im einstelligen Millisekundenbereich bietet und Daten dauerhaft in mehreren Availability Zones speichert. AWS Amazon Keyspaces fügt Metadaten an alle Zeilen und Primärschlüsselspalten an, um einen effizienten Datenzugriff und hohe Verfügbarkeit zu unterstützen.
Dieses Thema enthält Einzelheiten zur Schätzung der codierten Zeilengröße in Amazon Keyspaces. Die kodierte Zeilengröße wird bei der Berechnung Ihrer Rechnung und der Kontingentnutzung verwendet. Sie können die kodierte Zeilengröße auch verwenden, um die Anforderungen an die bereitgestellte Durchsatzkapazität für Tabellen zu schätzen.
Um die kodierte Größe von Zeilen in Amazon Keyspaces zu berechnen, können Sie die folgenden Richtlinien verwenden.
**Topics**
+ [
## Schätzen Sie die kodierte Größe von Spalten
](#calculating-row-size-columns)
+ [
## Schätzen Sie die kodierte Größe von Datenwerten auf der Grundlage des Datentyps
](#calculating-row-size-data-types)
+ [
## Berücksichtigen Sie die Auswirkungen der Funktionen von Amazon Keyspaces auf die Zeilengröße
](#calculating-row-size-features)
+ [
## Wählen Sie die richtige Formel, um die kodierte Größe einer Zeile zu berechnen
](#calculating-row-size-formula)
+ [
## Beispiel für die Berechnung der Zeilengröße
](#calculating-row-size-example)
## Schätzen Sie die kodierte Größe von Spalten
In diesem Abschnitt wird gezeigt, wie die kodierte Größe von Spalten in Amazon Keyspaces geschätzt wird.
+ **Reguläre Spalten** — Verwenden Sie für reguläre Spalten, bei denen es sich nicht um Primärschlüssel, Clusterspalten oder `STATIC` Spalten handelt, die Rohgröße der Zellendaten basierend auf dem [Datentyp](cql.elements.md#cql.data-types) und fügen Sie die erforderlichen Metadaten hinzu. Die Datentypen und einige wichtige Unterschiede in der Art und Weise, wie Amazon Keyspaces Datentypwerte und Metadaten speichert, sind im nächsten Abschnitt aufgeführt.
+ **Spalten mit Partitionsschlüsseln** — Partitionsschlüssel können bis zu 2048 Byte an Daten enthalten. Jede Schlüsselspalte im Partitionsschlüssel benötigt bis zu 3 Byte an Metadaten. Bei der Berechnung der Größe Ihrer Zeile sollten Sie davon ausgehen, dass jede Partitionsschlüsselspalte die vollen 3 Byte an Metadaten verwendet.
+ **Cluster-Spalten** — In Cluster-Spalten können bis zu 850 Byte an Daten gespeichert werden. Zusätzlich zur Größe des Datenwerts benötigt jede Clusterspalte bis zu 20% der Datenwertgröße für Metadaten. Bei der Berechnung der Größe Ihrer Zeile sollten Sie 1 Byte Metadaten für jeweils 5 Byte des Datenwerts der Clusterspalte hinzufügen.
**Anmerkung**
Um effiziente Abfragen und integrierte Indizierung zu unterstützen, speichert Amazon Keyspaces den Datenwert jeder Partitionsschlüssel- und Clusterschlüsselspalte zweimal.
+ **Spaltennamen** — Der für jeden Spaltennamen benötigte Speicherplatz wird unter Verwendung einer Spalten-ID gespeichert und zu jedem in der Spalte gespeicherten Datenwert hinzugefügt. Der Speicherwert der Spalten-ID hängt von der Gesamtzahl der Spalten in Ihrer Tabelle ab:
+ 1—62 Spalten: 1 Byte
+ 63—124 Spalten: 2 Byte
+ 125—186 Spalten: 3 Byte
Fügen Sie für jede weitere 62 Spalten 1 Byte hinzu. Beachten Sie, dass in Amazon Keyspaces bis zu 225 reguläre Spalten mit einer einzigen `INSERT` `UPDATE` OR-Anweisung geändert werden können. Weitere Informationen finden Sie unter [Amazon Keyspaces-Servicekontingente](quotas.md#table).
## Schätzen Sie die kodierte Größe von Datenwerten auf der Grundlage des Datentyps
In diesem Abschnitt wird gezeigt, wie die kodierte Größe verschiedener Datentypen in Amazon Keyspaces geschätzt wird.
+ **String-Typen** — Cassandra- `ASCII``TEXT`, und `VARCHAR` String-Datentypen werden alle in Amazon Keyspaces unter Verwendung von Unicode mit UTF-8-Binärkodierung gespeichert. Die Größe einer Zeichenfolge in Amazon Keyspaces entspricht der Anzahl der UTF-8-kodierten Byte.
+ **Numerische Typen** — Cassandra `INT``BIGINT`,, `SMALLINT``TINYINT`, und `VARINT` Datentypen werden in Amazon Keyspaces als Datenwerte mit variabler Länge mit bis zu 38 signifikanten Ziffern gespeichert. Nullen am Anfang und am Ende werden abgeschnitten. Die Größe jedes dieser Datentypen beträgt ungefähr 1 Byte pro zwei signifikanten Ziffern \$1 1 Byte.
+ **Blob-Typ** — A `BLOB` in Amazon Keyspaces wird mit der Roh-Bytelänge des Werts gespeichert.
+ **Boolescher Typ** — Die Größe eines `Boolean` Werts oder Werts beträgt 1 Byte`Null`.
+ **Sammlungstypen** — Eine Spalte, in der Sammlungsdatentypen wie Metadaten von 3 Byte gespeichert werden `LIST` oder diese `MAP` erfordern, unabhängig von ihrem Inhalt. Die Größe eines `LIST` oder `MAP` ist (Spalten-ID) \$1 Summe (Größe der verschachtelten Elemente) \$1 (3 Byte). Die Größe eines leeren `LIST` Or `MAP` ist (Spalten-ID) \$1 (3 Byte). Jedes Individuum `LIST` oder `MAP` Element benötigt außerdem 1 Byte an Metadaten.
+ **Benutzerdefinierte Typen** — Ein [benutzerdefinierter Typ (UDT)](udts.md) benötigt unabhängig von seinem Inhalt 3 Byte für Metadaten. Für jedes UDT-Element benötigt Amazon Keyspaces zusätzlich 1 Byte an Metadaten.
Um die kodierte Größe einer UDT zu berechnen, beginnen Sie mit dem `field name` und dem `field value` für die Felder einer UDT:
+ **Feldname** — Jeder Feldname der UDT der obersten Ebene wird unter Verwendung eines Bezeichners gespeichert. Der Speicherwert des Bezeichners hängt von der Gesamtzahl der Felder in Ihrer UDT der obersten Ebene ab und kann zwischen 1 und 3 Byte variieren:
+ 1—62 Felder: 1 Byte
+ 63—124 Felder: 2 Byte
+ 125 — maximale Anzahl an Feldern: 3 Byte
+ **Feldwert** — Die Byte, die zum Speichern der Feldwerte der UDT der obersten Ebene erforderlich sind, hängen vom gespeicherten Datentyp ab:
+ **Skalarer Datentyp** — Die für die Speicherung erforderlichen Byte sind dieselben wie für denselben Datentyp, der in einer regulären Spalte gespeichert ist.
+ **Eingefrorenes UDT** — Für jedes eingefrorene verschachtelte UDT hat das verschachtelte UDT dieselbe Größe wie im CQL-Binärprotokoll. Bei einer verschachtelten UDT werden 4 Byte für jedes Feld (einschließlich leerer Felder) gespeichert, und der Wert des gespeicherten Felds entspricht dem Serialisierungsformat des Feldwerts im CQL-Binärprotokoll.
+ **Gefrorene Sammlungen:**
+ **LIST** und **SET** — Bei einem verschachtelten`SET`, eingefrorenen `LIST` oder werden 4 Byte für jedes Element der Sammlung gespeichert, zuzüglich des Serialisierungsformats für den Wert der Sammlung im CQL-Binärprotokoll.
+ **MAP** — Für ein verschachteltes eingefrorenes Objekt gelten `MAP` für jedes Schlüssel-Wert-Paar die folgenden Speicheranforderungen:
+ Ordnen Sie jedem Schlüssel 4 Byte zu und fügen Sie dann das Serialisierungsformat des Schlüssels im CQL-Binärprotokoll hinzu.
+ Ordnen Sie jedem Wert 4 Byte zu und fügen Sie dann das Serialisierungsformat des Werts im CQL-Binärprotokoll hinzu.
+ **Schlüsselwort FROZEN** — Für eingefrorene Sammlungen, die in eingefrorenen Sammlungen verschachtelt sind, benötigt Amazon Keyspaces keine zusätzlichen Byte für Metadaten.
+ **STATISCHES Schlüsselwort** — `STATIC` Spaltendaten werden nicht auf die maximale Zeilengröße von 1 MB angerechnet. Informationen zur Berechnung der Datengröße statischer Spalten finden Sie unter[Berechnen Sie die statische Spaltengröße pro logischer Partition in Amazon Keyspaces](static-columns-estimate.md).
## Berücksichtigen Sie die Auswirkungen der Funktionen von Amazon Keyspaces auf die Zeilengröße
Dieser Abschnitt zeigt, wie sich Funktionen in Amazon Keyspaces auf die kodierte Größe einer Zeile auswirken.
+ **Clientseitige Zeitstempel — Clientseitige Zeitstempel** werden für jede Spalte in jeder Zeile gespeichert, wenn die Funktion aktiviert ist. Diese Zeitstempel nehmen ungefähr 20—40 Byte ein (abhängig von Ihren Daten) und tragen zu den Speicher- und Durchsatzkosten für die Zeile bei. Weitere Informationen zu clientseitigen Zeitstempeln finden Sie unter. [Clientseitige Zeitstempel in Amazon Keyspaces](client-side-timestamps.md)
+ **Time to Live (TTL)** — TTL-Metadaten nehmen ungefähr 8 Byte für eine Zeile ein, wenn die Funktion aktiviert ist. Darüber hinaus werden TTL-Metadaten für jede Spalte jeder Zeile gespeichert. Die TTL-Metadaten nehmen ungefähr 8 Byte für jede Spalte ein, in der ein skalarer Datentyp oder eine eingefrorene Sammlung gespeichert wird. Wenn die Spalte einen Sammlungsdatentyp speichert, der nicht eingefroren ist, benötigt TTL für jedes Element der Sammlung ungefähr 8 zusätzliche Byte für Metadaten. Für eine Spalte, die einen Sammlungsdatentyp speichert, wenn TTL aktiviert ist, können Sie die folgende Formel verwenden.
```
total encoded size of column = (column id) + sum (nested elements + collection metadata (1 byte) + TTL metadata (8 bytes)) + collection column metadata (3 bytes)
```
TTL-Metadaten tragen zu den Speicher- und Durchsatzkosten für die Zeile bei. Weitere Informationen zu TTL finden Sie unter [Daten mit Time to Live (TTL) für Amazon Keyspaces (für Apache Cassandra) ablaufen lassen](TTL.md).
## Wählen Sie die richtige Formel, um die kodierte Größe einer Zeile zu berechnen
Dieser Abschnitt zeigt die verschiedenen Formeln, mit denen Sie entweder den Speicher- oder den Kapazitätsdurchsatzbedarf für eine Datenzeile in Amazon Keyspaces schätzen können.
Die kodierte Gesamtgröße einer Datenzeile kann auf der Grundlage einer der folgenden Formeln geschätzt werden, basierend auf Ihrem Ziel:
+ **Durchsatzkapazität** — Um die kodierte Größe einer Zeile zu schätzen, um die erforderlichen read/write Anforderungseinheiten zu ermitteln ()RRUs/WRUs) or read/write capacity units (RCUs/WCUs:
```
total encoded size of row = partition key columns + clustering columns + regular columns
```
+ **Speichergröße** — Um die kodierte Größe einer Zeile zu schätzen und das vorherzusagen`BillableTableSizeInBytes`, fügen Sie die erforderlichen Metadaten für die Speicherung der Zeile hinzu:
```
total encoded size of row = partition key columns + clustering columns + regular columns + row metadata (100 bytes)
```
**Wichtig**
Alle Spaltenmetadaten, z. B. Spalten-IDs, Partitionsschlüssel-Metadaten, Cluster-Spaltenmetadaten sowie clientseitige Zeitstempel, TTL und Zeilenmetadaten werden auf die maximale Zeilengröße von 1 MB angerechnet.
## Beispiel für die Berechnung der Zeilengröße
Betrachten Sie das folgende Beispiel für eine Tabelle, in der alle Spalten vom Typ Integer sind. Die Tabelle hat zwei Partitionsschlüsselspalten, zwei Clusterspalten und eine reguläre Spalte. Da diese Tabelle fünf Spalten hat, beträgt der für den Spaltennamen benötigte Speicherplatz 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 diesem Beispiel berechnen wir die Datengröße, wenn wir eine Zeile in die Tabelle schreiben, wie in der folgenden Anweisung dargestellt:
```
INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, ck_col1, ck_col2, reg_col1) values(1,2,3,4,5);
```
Um die Gesamtanzahl der für diesen Schreibvorgang benötigten Byte zu schätzen, können Sie die folgenden Schritte verwenden.
1. Berechnen Sie die Größe einer Partitionsschlüsselspalte, indem Sie die Byte für den in der Spalte gespeicherten Datentyp und die Metadaten-Bytes addieren. Wiederholen Sie diesen Vorgang für alle Partitionsschlüsselspalten.
1. Berechnet die Größe der ersten Spalte des Partitionsschlüssels (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. Berechnet die Größe der zweiten Spalte des Partitionsschlüssels (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. Fügen Sie beide Spalten hinzu, um die geschätzte Gesamtgröße der Partitionsschlüsselspalten zu erhalten:
```
8 bytes + 8 bytes = 16 bytes for the partition key columns
```
1. Berechnen Sie die Größe der Clusterspalte, indem Sie die Byte für den in der Spalte gespeicherten Datentyp und die Metadaten-Bytes hinzufügen. Wiederholen Sie diesen Vorgang für alle Clusterspalten.
1. Berechnet die Größe der ersten Spalte der Cluster-Spalte (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. Berechnet die Größe der zweiten Spalte der Cluster-Spalte (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. Fügen Sie beide Spalten hinzu, um die geschätzte Gesamtgröße der Cluster-Spalten zu erhalten:
```
6 bytes + 6 bytes = 12 bytes for the clustering columns
```
1. Fügen Sie die Größe der regulären Spalten hinzu. In diesem Beispiel haben wir nur eine Spalte, die eine einstellige Ganzzahl speichert, was 2 Byte mit 1 Byte für die Spalten-ID erfordert.
1. Um schließlich die gesamte codierte Zeilengröße zu erhalten, addieren Sie die Byte für alle Spalten. Um die abrechnungsfähige Speichergröße zu schätzen, fügen Sie die zusätzlichen 100 Byte für Zeilenmetadaten hinzu:
```
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.
```
Informationen zur Überwachung serverloser Ressourcen mit Amazon finden Sie CloudWatch unter[Überwachung von Amazon Keyspaces mit Amazon CloudWatch](monitoring-cloudwatch.md).
# Schätzen Sie den Kapazitätsverbrauch des Lese- und Schreibdurchsatzes in Amazon Keyspaces
Wenn Sie Daten in Amazon Keyspaces lesen oder schreiben, hängt die Anzahl der read/write Anforderungseinheiten (RRUs/WRUs) or read/write capacity units (RCUs/WCUs), die Ihre Abfrage verbraucht, von der Gesamtmenge an Daten ab, die Amazon Keyspaces verarbeiten muss, um die Abfrage auszuführen. In einigen Fällen können die an den Client zurückgegebenen Daten eine Teilmenge der Daten sein, die Amazon Keyspaces lesen musste, um die Abfrage zu verarbeiten. Bei bedingten Schreibvorgängen verbraucht Amazon Keyspaces Schreibkapazität, auch wenn die bedingte Prüfung fehlschlägt.
Um die Gesamtmenge der für eine Anfrage verarbeiteten Daten abzuschätzen, müssen Sie die kodierte Größe einer Zeile und die Gesamtzahl der Zeilen berücksichtigen. In diesem Thema werden einige Beispiele für gängige Szenarien und Zugriffsmuster behandelt, um zu zeigen, wie Amazon Keyspaces Abfragen verarbeitet und wie sich dies auf den Kapazitätsverbrauch auswirkt. Sie können den Beispielen folgen, um den Kapazitätsbedarf Ihrer Tabellen abzuschätzen, und Amazon verwenden, CloudWatch um den Lese- und Schreibkapazitätsverbrauch für diese Anwendungsfälle zu beobachten.
Informationen zur Berechnung der codierten Zeilengröße in Amazon Keyspaces finden Sie unter. [Schätzen Sie die Zeilengröße in Amazon Keyspaces](calculating-row-size.md)
**Topics**
+ [
# Schätzen Sie den Kapazitätsverbrauch von Bereichsabfragen in Amazon Keyspaces
](range_queries.md)
+ [
# Schätzen Sie den Lesekapazitätsverbrauch von Grenzabfragen
](limit_queries.md)
+ [
# Schätzen Sie den Lesekapazitätsverbrauch von Tabellenscans
](table_scans.md)
+ [
# Schätzen Sie den Kapazitätsverbrauch leichter Transaktionen in Amazon Keyspaces
](lightweight_transactions.md)
+ [
# Schätzen Sie den Kapazitätsverbrauch für statische Spalten in Amazon Keyspaces
](static-columns.md)
+ [
# Schätzung und Bereitstellung der Kapazität für eine Tabelle mit mehreren Regionen in Amazon Keyspaces
](tables-multi-region-capacity.md)
+ [
# Schätzen Sie den Lese- und Schreibkapazitätsverbrauch mit Amazon CloudWatch in Amazon Keyspaces
](estimate_consumption_cw.md)
# Schätzen Sie den Kapazitätsverbrauch von Bereichsabfragen in Amazon Keyspaces
Um den Lesekapazitätsverbrauch einer Bereichsabfrage zu untersuchen, verwenden wir die folgende Beispieltabelle, die den On-Demand-Kapazitätsmodus verwendet.
```
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 |
```
Führen Sie nun die folgende Abfrage für diese Tabelle aus.
```
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;
```
Sie erhalten die folgende Ergebnismenge aus der Abfrage und der von Amazon Keyspaces ausgeführte Lesevorgang verbraucht 2 RRUs im `LOCAL_QUORUM` Konsistenzmodus.
```
pk1 | pk2 | pk3 | ck1 | ck2 | ck3 | value
-----+-----+-----+-----+-----+-----+-------
a | b | 1 | a | b | 60 | value_1
```
Amazon Keyspaces verbraucht 2 RRUs , um die Zeilen mit den Werten auszuwerten `ck3=60` und die Abfrage `ck3=70` zu verarbeiten. Amazon Keyspaces gibt jedoch nur die Zeile zurück, in der die in der Abfrage angegebene `WHERE` Bedingung wahr ist, also die Zeile mit dem Wert`ck3=60`. Um den in der Abfrage angegebenen Bereich auszuwerten, liest Amazon Keyspaces in diesem Fall die Zeile, die der Obergrenze des Bereichs entspricht`ck3 = 70`, gibt diese Zeile jedoch nicht im Ergebnis zurück. Der Lesekapazitätsverbrauch basiert auf den bei der Verarbeitung der Abfrage gelesenen Daten, nicht auf den zurückgegebenen Daten.
# Schätzen Sie den Lesekapazitätsverbrauch von Grenzabfragen
Bei der Verarbeitung einer Abfrage, die die `LIMIT` Klausel verwendet, liest Amazon Keyspaces Zeilen bis zur maximalen Seitengröße, wenn versucht wird, die in der Abfrage angegebene Bedingung zu erfüllen. Wenn Amazon Keyspaces nicht genügend übereinstimmende Daten finden kann, die dem `LIMIT` Wert auf der ersten Seite entsprechen, sind möglicherweise ein oder mehrere paginierte Aufrufe erforderlich. Um mit dem Lesen auf der nächsten Seite fortzufahren, können Sie ein Paginierungstoken verwenden. Die Standard-Seitengröße ist 1 MB. Um bei der Verwendung von `LIMIT` Klauseln weniger Lesekapazität zu verbrauchen, können Sie die Seitengröße reduzieren. Weitere Hinweise zur Seitennummerierung finden Sie unter. [Ergebnisse in Amazon Keyspaces paginieren](paginating-results.md)
Schauen wir uns als Beispiel die folgende Abfrage an.
```
SELECT * FROM my_table WHERE partition_key=1234 LIMIT 1;
```
Wenn Sie die Seitengröße nicht festlegen, liest Amazon Keyspaces 1 MB an Daten, obwohl es Ihnen nur 1 Zeile zurückgibt. Damit Amazon Keyspaces nur eine Zeile liest, können Sie die Seitengröße für diese Abfrage auf 1 setzen. In diesem Fall würde Amazon Keyspaces nur eine Zeile lesen, vorausgesetzt, Sie haben keine abgelaufenen Zeilen, die auf Time-to-live Einstellungen oder clientseitigen Zeitstempeln basieren.
Der `PAGE SIZE` Parameter bestimmt, wie viele Zeilen Amazon Keyspaces für jede Anfrage von der Festplatte scannt, nicht, wie viele Zeilen Amazon Keyspaces an den Client zurückgibt. Amazon Keyspaces wendet die von Ihnen angegebenen Filter an, z. B. Ungleichheit bei Nichtschlüsselspalten oder `LIMIT` nach dem Scannen der Daten auf der Festplatte. Wenn Sie das nicht explizit festlegen`PAGE SIZE`, liest Amazon Keyspaces bis zu 1 MB an Daten, bevor Filter angewendet werden. Wenn Sie beispielsweise `LIMIT 1` ohne Angabe von verwenden`PAGE SIZE`, könnte Amazon Keyspaces Tausende von Zeilen von der Festplatte lesen, bevor die Limit-Klausel angewendet und nur eine einzige Zeile zurückgegeben wird.
Um zu viel Lesen zu vermeiden, reduzieren Sie `PAGE SIZE` die Anzahl der Zeilen, die Amazon Keyspaces bei jedem Abruf scannt. Wenn Sie beispielsweise `LIMIT 5` in Ihrer Abfrage definieren, legen Sie für einen Wert zwischen 5 und 10 fest, sodass Amazon Keyspaces bei jedem paginierten Aufruf nur 5 bis 10 Zeilen scannt. `PAGE SIZE` Sie können diese Zahl ändern, um die Anzahl der Abrufe zu reduzieren. Für Grenzwerte, die größer als die Seitengröße sind, behält Amazon Keyspaces die Gesamtzahl der Ergebnisse mit Paginierungsstatus bei. Bei 10.000 Zeilen kann Amazon Keyspaces diese Ergebnisse auf zwei Seiten mit jeweils 5.000 Zeilen abrufen. `LIMIT` Das Limit von 1 MB ist die Obergrenze für jede festgelegte Seitengröße.
# Schätzen Sie den Lesekapazitätsverbrauch von Tabellenscans
Abfragen, die zu vollständigen Tabellenscans führen, z. B. Abfragen, die die `ALLOW FILTERING` Option verwenden, sind ein weiteres Beispiel für Abfragen, die mehr Lesevorgänge verarbeiten, als sie als Ergebnisse zurückgeben. Und der Lesekapazitätsverbrauch basiert auf den gelesenen Daten, nicht auf den zurückgegebenen Daten.
Für das Beispiel für den Tabellenscan verwenden wir die folgende Beispieltabelle im On-Demand-Kapazitätsmodus.
```
pk | ck | value
---+----+---------
pk | 10 |
pk | 20 | value_1
pk | 30 |
```
Amazon Keyspaces erstellt standardmäßig eine Tabelle im On-Demand-Kapazitätsmodus mit vier Partitionen. In dieser Beispieltabelle werden alle Daten in einer Partition gespeichert und die restlichen drei Partitionen sind leer.
Führen Sie nun die folgende Abfrage für die Tabelle aus.
```
SELECT * from amazon_keyspaces.example_table_2;
```
Diese Abfrage führt zu einem Tabellenscanvorgang, bei dem Amazon Keyspaces alle vier Partitionen der Tabelle scannt und RRUs im `LOCAL_QUORUM` Konsistenzmodus 6 Partitionen verbraucht. Erstens verbraucht Amazon Keyspaces 3 RRUs für das Lesen der drei Zeilen mit. `pk=‘pk’` Dann verbraucht Amazon Keyspaces die zusätzlichen 3 RRUs für das Scannen der drei leeren Partitionen der Tabelle. Da diese Abfrage zu einem Tabellenscan führt, scannt Amazon Keyspaces alle Partitionen in der Tabelle, einschließlich Partitionen ohne Daten.
# Schätzen Sie den Kapazitätsverbrauch leichter Transaktionen in Amazon Keyspaces
Lightweight Transactions (LWT) ermöglichen es Ihnen, bedingte Schreiboperationen für Ihre Tabellendaten durchzuführen. Bedingte Aktualisierungsoperationen sind nützlich, wenn Datensätze auf der Grundlage von Bedingungen eingefügt, aktualisiert und gelöscht werden, die den aktuellen Status bewerten.
In Amazon Keyspaces erfordern alle Schreibvorgänge die Konsistenz LOCAL\$1QUORUM, und es fallen keine zusätzlichen Gebühren für die Verwendung an. LWTs Der Unterschied besteht LWTs darin, dass Amazon Keyspaces Schreibkapazitätseinheiten (WCUs) oder Schreibanforderungseinheiten () verbraucht`FALSE`, wenn eine LWT-Zustandsprüfung ergibt. WRUs Die Anzahl der WCUs/WRUs verbrauchten Daten hängt von der Größe der Zeile ab.
Wenn die Zeilengröße beispielsweise 2 KB beträgt, verbraucht der fehlgeschlagene bedingte Schreibvorgang zwei WCUs/WRUs. Wenn die Zeile derzeit nicht in der Tabelle vorhanden ist, verbraucht der Vorgang einen WCUs Wert vom Typ/. WRUs
Um die Anzahl der Anfragen zu ermitteln, die zu Fehlschlägen bei der Zustandsprüfung geführt haben, können Sie die `ConditionalCheckFailed` Metrik in CloudWatch überwachen.
## Schätzen Sie die LWT-Kosten für Tabellen mit Time to Live (TTL)
LWTs kann zusätzliche Lesekapazitätseinheiten (RCUs) oder Leseanforderungseinheiten (RRUs) für Tabellen erfordern, die mit TTL konfiguriert sind und keine clientseitigen Zeitstempel verwenden. Bei Verwendung von `IF EXISTS` oder `IF NOT EXISTS` Schlüsselwörtern mit Ergebnissen der Zustandsprüfung werden die folgenden Kapazitätseinheiten verbraucht: `FALSE`
+ RCUs/RRUs – If the row exists, the RCUs/RRUsDie verbrauchten Daten basieren auf der Größe der vorhandenen Zeile.
+ RCUs/RRUs – If the row doesn't exist, a single RCU/RRUwird verbraucht.
Wenn die ausgewertete Bedingung zu einem erfolgreichen Schreibvorgang führt, WCUs/WRUs werden sie auf der Grundlage der Größe der neuen Zeile verbraucht.
# Schätzen Sie den Kapazitätsverbrauch für statische Spalten in Amazon Keyspaces
In einer Amazon Keyspaces-Tabelle mit Clusterspalten können Sie das `STATIC` Schlüsselwort verwenden, um eine statische Spalte zu erstellen. Der in einer statischen Spalte gespeicherte Wert wird von allen Zeilen in einer logischen Partition gemeinsam genutzt. Wenn Sie den Wert dieser Spalte aktualisieren, wendet Amazon Keyspaces die Änderung automatisch auf alle Zeilen in der Partition an.
In diesem Abschnitt wird beschrieben, wie Sie die kodierte Datengröße berechnen, wenn Sie in statische Spalten schreiben. Dieser Vorgang wird getrennt von dem Prozess durchgeführt, bei dem Daten in die nichtstatischen Spalten einer Zeile geschrieben werden. Neben den Größenkontingenten für statische Daten wirken sich Lese- und Schreibvorgänge an statischen Spalten auch unabhängig voneinander auf die Messung und die Durchsatzkapazität von Tabellen aus. Informationen zu den funktionellen Unterschieden zu Apache Cassandra bei der Verwendung statischer Spalten und paginierter Leseergebnisse finden Sie unter. [Paginierung](functional-differences.md#functional-differences.paging)
**Topics**
+ [
# Berechnen Sie die statische Spaltengröße pro logischer Partition in Amazon Keyspaces
](static-columns-estimate.md)
+ [
# Schätzen Sie die Kapazitätsdurchsatzanforderungen für read/write Operationen mit statischen Daten in Amazon Keyspaces
](static-columns-metering.md)
# Berechnen Sie die statische Spaltengröße pro logischer Partition in Amazon Keyspaces
Dieser Abschnitt enthält Einzelheiten zur Schätzung der codierten Größe statischer Spalten in Amazon Keyspaces. Die kodierte Größe wird bei der Berechnung Ihrer Rechnung und der Kontingentnutzung verwendet. Sie sollten die kodierte Größe auch verwenden, wenn Sie die Anforderungen an die bereitgestellte Durchsatzkapazität für Tabellen berechnen. Um die kodierte Größe statischer Spalten in Amazon Keyspaces zu berechnen, können Sie die folgenden Richtlinien verwenden.
+ Partitionsschlüssel können bis zu 2048 Byte an Daten enthalten. Jede Schlüsselspalte im Partitionsschlüssel benötigt bis zu 3 Byte an Metadaten. Diese Metadaten-Bytes werden auf Ihr statisches Datengrößenkontingent von 1 MB pro Partition angerechnet. Bei der Berechnung der Größe Ihrer statischen Daten sollten Sie davon ausgehen, dass jede Partitionsschlüsselspalte die vollen 3 Byte an Metadaten verwendet.
+ Verwenden Sie die Rohgröße der statischen Spaltendatenwerte basierend auf dem Datentyp. Weitere Informationen zu Datentypen finden Sie unter [Datentypen](cql.elements.md#cql.data-types).
+ Fügen Sie der Größe der statischen Daten für Metadaten 104 Byte hinzu.
+ Clusterspalten und normale Spalten, die keine Primärschlüsselspalten sind, werden nicht auf die Größe statischer Daten angerechnet. Informationen zum Schätzen der Größe nichtstatischer Daten innerhalb von Zeilen finden Sie unter. [Schätzen Sie die Zeilengröße in Amazon Keyspaces](calculating-row-size.md)
Die kodierte Gesamtgröße einer statischen Spalte basiert auf der folgenden Formel:
```
partition key columns + static columns + metadata = total encoded size of static data
```
Betrachten Sie das folgende Beispiel für eine Tabelle, in der alle Spalten vom Typ Integer sind. Die Tabelle hat zwei Partitionsschlüsselspalten, zwei Clusterspalten, eine reguläre Spalte und eine statische Spalte.
```
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 diesem Beispiel berechnen wir die Größe der statischen Daten der folgenden Anweisung:
```
INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, static_col1) values(1,2,6);
```
Um die Gesamtanzahl der für diesen Schreibvorgang benötigten Byte abzuschätzen, können Sie die folgenden Schritte verwenden.
1. Berechnen Sie die Größe einer Partitionsschlüsselspalte, indem Sie die Byte für den in der Spalte gespeicherten Datentyp und die Metadaten-Bytes addieren. Wiederholen Sie diesen Vorgang für alle Partitionsschlüsselspalten.
1. Berechnet die Größe der ersten Spalte des Partitionsschlüssels (pk\$1col1):
```
4 bytes for the integer data type + 3 bytes for partition key metadata = 7 bytes
```
1. Berechnet die Größe der zweiten Spalte des Partitionsschlüssels (pk\$1col2):
```
4 bytes for the integer data type + 3 bytes for partition key metadata = 7 bytes
```
1. Fügen Sie beide Spalten hinzu, um die geschätzte Gesamtgröße der Partitionsschlüsselspalten zu erhalten:
```
7 bytes + 7 bytes = 14 bytes for the partition key columns
```
1. Fügen Sie die Größe der statischen Spalten hinzu. In diesem Beispiel haben wir nur eine statische Spalte, die eine Ganzzahl speichert (was 4 Byte erfordert).
1. Um schließlich die gesamte kodierte Größe der statischen Spaltendaten zu ermitteln, addieren Sie die Byte für die Primärschlüsselspalten und statischen Spalten und fügen Sie die zusätzlichen 104 Byte für Metadaten hinzu:
```
14 bytes for the partition key columns + 4 bytes for the static column + 104 bytes for metadata = 122 bytes.
```
Sie können statische und nicht statische Daten auch mit derselben Anweisung aktualisieren. Um die Gesamtgröße des Schreibvorgangs abzuschätzen, müssen Sie zunächst den Umfang der nichtstatischen Datenaktualisierung berechnen. Berechnen Sie dann die Größe der Zeilenaktualisierung, wie im Beispiel unter gezeigt[Schätzen Sie die Zeilengröße in Amazon Keyspaces](calculating-row-size.md), und fügen Sie die Ergebnisse hinzu.
In diesem Fall können Sie insgesamt 2 MB schreiben — 1 MB ist das maximale Zeilengrößenkontingent und 1 MB ist das Kontingent für die maximale statische Datengröße pro logischer Partition.
Um die Gesamtgröße einer Aktualisierung statischer und nicht statischer Daten in derselben Anweisung zu berechnen, können Sie die folgende Formel verwenden:
```
(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
```
Betrachten Sie das folgende Beispiel für eine Tabelle, in der alle Spalten vom Typ Integer sind. Die Tabelle hat zwei Partitionsschlüsselspalten, zwei Clusterspalten, eine reguläre Spalte und eine statische Spalte.
```
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 diesem Beispiel berechnen wir die Datengröße, wenn wir eine Zeile in die Tabelle schreiben, wie in der folgenden Anweisung dargestellt:
```
INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, ck_col1, ck_col2, reg_col1, static_col1) values(2,3,4,5,6,7);
```
Um die Gesamtanzahl der für diesen Schreibvorgang benötigten Byte zu schätzen, können Sie die folgenden Schritte verwenden.
1. Berechnen Sie die gesamte kodierte Größe der statischen Daten wie zuvor gezeigt. In diesem Beispiel sind es 122 Byte.
1. Fügen Sie die Größe der codierten Gesamtgröße der Zeile hinzu, die auf der Aktualisierung nicht statischer Daten basiert. Gehen Sie dabei wie unter beschrieben vor. [Schätzen Sie die Zeilengröße in Amazon Keyspaces](calculating-row-size.md) In diesem Beispiel beträgt die Gesamtgröße der Zeilenaktualisierung 134 Byte.
```
122 bytes for static data + 134 bytes for nonstatic data = 256 bytes.
```
# Schätzen Sie die Kapazitätsdurchsatzanforderungen für read/write Operationen mit statischen Daten in Amazon Keyspaces
Statische Daten sind logischen Partitionen in Cassandra zugeordnet, nicht einzelnen Zeilen. Logische Partitionen in Amazon Keyspaces können in ihrer Größe praktisch unbegrenzt sein, da sie sich über mehrere physische Speicherpartitionen erstrecken. Aus diesem Grund schreiben Amazon Keyspaces-Messgeräte Operationen für statische und nichtstatische Daten getrennt. Darüber hinaus erfordern Schreibvorgänge, die sowohl statische als auch nicht statische Daten enthalten, zusätzliche zugrunde liegende Operationen, um die Datenkonsistenz zu gewährleisten.
Wenn Sie einen gemischten Schreibvorgang für statische und nicht statische Daten ausführen, führt dies zu zwei separaten Schreibvorgängen — einer für nicht statische und einer für statische Daten. Dies gilt sowohl für den bedarfsgesteuerten als auch für den Modus mit bereitgestellter Kapazität. read/write
Das folgende Beispiel enthält Details zur Schätzung der erforderlichen Lesekapazitätseinheiten (RCUs) und Schreibkapazitätseinheiten (WCUs), wenn Sie die Anforderungen an die bereitgestellte Durchsatzkapazität für Tabellen in Amazon Keyspaces mit statischen Spalten berechnen. Mithilfe der folgenden Formel können Sie abschätzen, wie viel Kapazität Ihre Tabelle für die Verarbeitung von Schreibvorgängen benötigt, die sowohl statische als auch nichtstatische Daten enthalten:
```
2 x WCUs required for nonstatic data + 2 x WCUs required for static data
```
Wenn Ihre Anwendung beispielsweise 27 KBs Daten pro Sekunde schreibt und jeder Schreibvorgang 25,5 KBs nichtstatische Daten und 1,5 KBs statische Daten umfasst, benötigt Ihre Tabelle 56 WCUs (2 x 26 WCUs \$1 2 x 2). WCUs
Amazon Keyspaces misst die Lesevorgänge statischer und nichtstatischer Daten genauso wie die Lesevorgänge mehrerer Zeilen. Daher basiert der Preis für das Lesen statischer und nichtstatischer Daten in derselben Operation auf der Gesamtgröße der Daten, die für den Lesevorgang verarbeitet wurden.
Informationen zur Überwachung serverloser Ressourcen mit Amazon finden Sie CloudWatch unter[Überwachung von Amazon Keyspaces mit Amazon CloudWatch](monitoring-cloudwatch.md).
# Schätzung und Bereitstellung der Kapazität für eine Tabelle mit mehreren Regionen in Amazon Keyspaces
Sie können die Durchsatzkapazität einer Tabelle mit mehreren Regionen auf eine von zwei Arten konfigurieren:
+ Kapazitätsmodus auf Abruf, gemessen in Schreibanforderungseinheiten () WRUs
+ Bereitgestellter Kapazitätsmodus mit auto Skalierung, gemessen in Schreibkapazitätseinheiten () WCUs
Sie können den Modus für bereitgestellte Kapazität mit Auto Scaling oder den On-Demand-Kapazitätsmodus verwenden, um sicherzustellen, dass eine Tabelle mit mehreren Regionen über ausreichend Kapazität verfügt, um replizierte Schreibvorgänge für alle durchzuführen. AWS-Regionen
**Anmerkung**
Wenn Sie den Kapazitätsmodus der Tabelle in einer der Regionen ändern, wird der Kapazitätsmodus für alle Replikate geändert.
Standardmäßig verwendet Amazon Keyspaces den On-Demand-Modus für Tabellen mit mehreren Regionen. Im On-Demand-Modus müssen Sie nicht angeben, wie viel Lese- und Schreibdurchsatz Sie von Ihrer Anwendung erwarten. Amazon Keyspaces passt sich sofort Ihren Workloads an, wenn sie auf ein zuvor erreichtes Datenverkehrsniveau hoch- oder herunterfahren. Wenn der Traffic eines Workloads einen neuen Höhepunkt erreicht, passt sich Amazon Keyspaces schnell an den Workload an.
Wenn Sie den Modus Bereitgestellte Kapazität für eine Tabelle wählen, müssen Sie die Anzahl der Lesekapazitätseinheiten (RCUs) und Schreibkapazitätseinheiten (WCUs) pro Sekunde konfigurieren, die Ihre Anwendung benötigt.
Um den Durchsatzkapazitätsbedarf einer Tabelle mit mehreren Regionen zu planen, sollten Sie zunächst abschätzen, wie viele WCUs pro Sekunde für jede Region benötigt werden. Dann addieren Sie die Schreibvorgänge aus allen Regionen, in denen Ihre Tabelle repliziert wird, und verwenden die Summe, um Kapazität für jede Region bereitzustellen. Dies ist erforderlich, da jeder Schreibvorgang, der in einer Region ausgeführt wird, auch in jeder Replikatregion wiederholt werden muss.
Wenn die Tabelle nicht über genügend Kapazität verfügt, um die Schreibvorgänge aus allen Regionen zu verarbeiten, treten Kapazitätsausnahmen auf. Darüber hinaus werden die Wartezeiten bei der interregionalen Replikation zunehmen.
Wenn Sie beispielsweise über eine Tabelle mit mehreren Regionen verfügen, in der Sie 5 Schreibvorgänge pro Sekunde in USA Ost (Nord-Virginia), 10 Schreibvorgänge pro Sekunde in USA Ost (Ohio) und 5 Schreibvorgänge pro Sekunde in Europa (Irland) erwarten, sollten Sie damit rechnen, dass die Tabelle WCUs in jeder Region 20 Schreibvorgänge verbraucht: USA Ost (Nord-Virginia), USA Ost (Ohio) und Europa (Irland). Das bedeutet, dass Sie in diesem Beispiel 20 WCUs für jedes Replikat der Tabelle bereitstellen müssen. Sie können den Kapazitätsverbrauch Ihrer Tabelle mit Amazon überwachen CloudWatch. Weitere Informationen finden Sie unter [Überwachung von Amazon Keyspaces mit Amazon CloudWatch](monitoring-cloudwatch.md).
Jeder Schreibvorgang wird mit 1 WCU abgerechnet. In diesem Beispiel würden also insgesamt 60 WCU WCUs abgerechnet. Weitere Informationen zu den Preisen finden Sie unter [Amazon Keyspaces (für Apache Cassandra)](https://aws.amazon.com/keyspaces/pricing) — Preise.
Weitere Informationen zur bereitgestellten Kapazität mit Amazon Keyspaces Auto Scaling finden Sie unter. [Automatische Verwaltung der Durchsatzkapazität mit Amazon Keyspaces Auto Scaling](autoscaling.md)
**Anmerkung**
Wenn eine Tabelle im Modus für bereitgestellte Kapazität mit Auto Scaling ausgeführt wird, darf die bereitgestellte Schreibkapazität innerhalb dieser Auto Scaling-Einstellungen für jede Region schwanken.
# Schätzen Sie den Lese- und Schreibkapazitätsverbrauch mit Amazon CloudWatch in Amazon Keyspaces
Um den Lese- und Schreibkapazitätsverbrauch abzuschätzen und zu überwachen, können Sie ein CloudWatch Dashboard verwenden. Weitere Informationen zu verfügbaren Metriken für Amazon Keyspaces finden Sie unter[Amazon Keyspaces-Metriken und -Dimensionen](metrics-dimensions.md).
Gehen Sie wie folgt vor, um die Lese- und Schreibkapazitätseinheiten zu überwachen CloudWatch, die von einer bestimmten Anweisung mit verbraucht werden.
1. Erstellen Sie eine neue Tabelle mit Beispieldaten
1. Konfigurieren Sie ein Amazon CloudWatch Keyspaces-Dashboard für die Tabelle. Zu Beginn können Sie eine Dashboard-Vorlage verwenden, die auf [Github](https://github.com/aws-samples/amazon-keyspaces-cloudwatch-cloudformation-templates) verfügbar ist.
1. Führen Sie die CQL-Anweisung aus, beispielsweise mit der `ALLOW FILTERING` Option, und überprüfen Sie im Dashboard, welche Lesekapazitätseinheiten für den vollständigen Tabellenscan verbraucht wurden.
# read/write Kapazitätsmodi in Amazon Keyspaces konfigurieren
Amazon Keyspaces bietet zwei read/write Kapazitätsmodi für die Verarbeitung von Lese- und Schreibvorgängen in Ihren Tabellen:
+ Auf Abruf (Standard)
+ Bereitgestellt
Der von Ihnen gewählte read/write Kapazitätsmodus steuert, wie Ihnen der Lese- und Schreibdurchsatz in Rechnung gestellt wird und wie die Tabellendurchsatzkapazität verwaltet wird.
**Topics**
+ [
# Konfigurieren Sie den Kapazitätsmodus auf Anforderung
](ReadWriteCapacityMode.OnDemand.md)
+ [
# Konfigurieren Sie den Modus für bereitgestellte Kapazität
](ReadWriteCapacityMode.Provisioned.md)
+ [
# Den Kapazitätsmodus einer Tabelle in Amazon Keyspaces anzeigen
](ReadWriteCapacityMode.ProvisionedThroughput.ManagingCapacity.md)
+ [
# Ändern Sie den Kapazitätsmodus einer Tabelle in Amazon Keyspaces
](ReadWriteCapacityMode.SwitchReadWriteCapacityMode.md)
+ [
# Vorwärmung für Tabellen in Amazon Keyspaces konfigurieren
](warm-throughput.md)
# Konfigurieren Sie den Kapazitätsmodus auf Anforderung
Der *On-Demand-Kapazitätsmodus* von Amazon Keyspaces (für Apache Cassandra) ist eine flexible Abrechnungsoption, mit der Tausende von Anfragen pro Sekunde ohne Kapazitätsplanung bearbeitet werden können. Diese Option bietet pay-per-request Preise für Lese- und Schreibanfragen, sodass Sie nur für das bezahlen, was Sie tatsächlich nutzen.
Wenn Sie den On-Demand-Modus wählen, kann Amazon Keyspaces die Durchsatzkapazität für Ihre Tabelle sofort auf jedes zuvor erreichte Datenverkehrsniveau hochskalieren und dann wieder herunterfahren, wenn der Anwendungsverkehr abnimmt. Wenn der Traffic eines Workloads einen neuen Höhepunkt erreicht, passt sich der Service schnell an, um die Durchsatzkapazität für Ihre Tabelle zu erhöhen. Sie können den On-Demand-Kapazitätsmodus sowohl für neue als auch für bestehende Tabellen aktivieren.
Der On-Demand-Modus ist eine gute Option, wenn eine der folgenden Bedingungen zutrifft:
+ Sie erstellen neue Tabellen mit unbekannten Workloads.
+ Der Datenverkehr Ihrer Anwendung ist nicht berechenbar.
+ Sie ziehen es vor, nur für Ihre tatsächliche Nutzung zu zahlen.
Um mit dem On-Demand-Modus zu beginnen, können Sie mithilfe der Konsole oder mit einigen Zeilen Cassandra Query Language (CQL) -Code eine neue Tabelle erstellen oder eine vorhandene Tabelle aktualisieren, um den On-Demand-Kapazitätsmodus zu verwenden. Weitere Informationen finden Sie unter [Tabellen](cql.ddl.table.md).
**Topics**
+ [
## Leseanforderungseinheiten und Schreibanforderungseinheiten
](#ReadWriteCapacityMode.requests)
+ [
## Spitzenaufkommen an Datenverkehr und Skalierungseigenschaften
](#ReadWriteCapacityMode.PeakTraffic)
+ [
## Anfänglicher Durchsatz für den On-Demand-Kapazitätsmodus
](#ReadWriteCapacityMode.InitialThroughput)
## Leseanforderungseinheiten und Schreibanforderungseinheiten
Bei Tabellen im On-Demand-Kapazitätsmodus müssen Sie nicht im Voraus angeben, wie viel Lese- und Schreibdurchsatz Ihre Anwendung voraussichtlich verwenden soll. Amazon Keyspaces berechnet Ihnen die Lese- und Schreibvorgänge, die Sie an Ihren Tabellen durchführen, in Form von Leseanforderungseinheiten (RRUs) und Schreibanforderungseinheiten (WRUs).
+ Eine *RRU* steht für eine `LOCAL_QUORUM` Leseanforderung oder zwei ` LOCAL_ONE` Leseanfragen für eine Zeile mit einer Größe von bis zu 4 KB. Wenn Sie eine Zeile lesen müssen, die größer als 4 KB ist, verwendet der Lesevorgang zusätzliche RRUs Daten. Die Gesamtzahl der RRUs erforderlichen Daten hängt von der Zeilengröße ab und davon, ob Sie Konsistenzen verwenden `LOCAL_QUORUM` oder `LOCAL_ONE` lesen möchten. Zum Lesen einer 8-KB-Zeile sind beispielsweise 2 RRUs unter Verwendung von `LOCAL_QUORUM` Lesekonsistenz und 1 RRU erforderlich, wenn Sie `LOCAL_ONE` Lesekonsistenz wählen.
+ Eine *WRU* steht für einen Schreibvorgang für eine Zeile mit einer Größe von bis zu 1 KB. Bei allen Schreibvorgängen wird `LOCAL_QUORUM` Konsistenz verwendet, und es fallen keine zusätzlichen Gebühren für die Verwendung von Lightweight Transactions (LWTs) an. Wenn Sie eine Zeile schreiben müssen, die größer als 1 KB ist, verwendet der Schreibvorgang zusätzliche Daten WRUs. Die Gesamtzahl der WRUs erforderlichen Dateien hängt von der Zeilengröße ab. Wenn Ihre Zeilengröße beispielsweise 2 KB beträgt, benötigen Sie 2, WRUs um eine Schreibanforderung auszuführen.
Informationen zu den unterstützten Konsistenzstufen finden Sie unter[Unterstützte Lese- und Schreibkonsistenzstufen von Apache Cassandra und damit verbundene Kosten](consistency.md).
## Spitzenaufkommen an Datenverkehr und Skalierungseigenschaften
Amazon Keyspaces-Tabellen, die den On-Demand-Kapazitätsmodus verwenden, passen sich automatisch an das Datenverkehrsvolumen Ihrer Anwendung an. Der On-Demand-Kapazitätsmodus passt sich sofort an bis zu das Doppelte des vorherigen Höchststands des Datenverkehrs für eine Tabelle an. Beispielsweise kann das Datenverkehrsmuster Ihrer Anwendung zwischen 5.000 und 10.000 `LOCAL_QUORUM` Lesevorgängen pro Sekunde variieren, wobei 10.000 Lesevorgänge pro Sekunde die vorherige Verkehrsspitze sind.
Bei diesem Muster ermöglicht der On-Demand-Kapazitätsmodus sofort einen anhaltenden Datenverkehr von bis zu 20.000 Lesevorgängen pro Sekunde. Wenn Ihre Anwendung einen Datenverkehr von 20.000 Lesevorgängen pro Sekunde aushält, wird dieser Spitzenwert zu Ihrem neuen vorherigen Spitzenwert, sodass der nachfolgende Datenverkehr bis zu 40.000 Lesevorgänge pro Sekunde erreichen kann.
Wenn Sie mehr als das Doppelte Ihres vorherigen Spitzenwerts in einer Tabelle benötigen, weist Amazon Keyspaces automatisch mehr Kapazität zu, wenn Ihr Verkehrsaufkommen steigt. Dadurch wird sichergestellt, dass Ihre Tabelle über genügend Durchsatzkapazität verfügt, um die zusätzlichen Anfragen zu verarbeiten. Sie können jedoch Fehler mit unzureichender Durchsatzkapazität feststellen, wenn Sie innerhalb von 30 Minuten das Doppelte Ihres vorherigen Spitzenwerts überschreiten.
Nehmen wir beispielsweise an, dass das Datenverkehrsmuster Ihrer Anwendung zwischen 5.000 und 10.000 stark konsistenten Lesevorgängen pro Sekunde variiert, wobei 20.000 Lesevorgänge pro Sekunde die zuvor erreichte Verkehrsspitze sind. In diesem Fall empfiehlt der Service, dass Sie Ihr Traffic-Wachstum über mindestens 30 Minuten verteilen, bevor Sie bis zu 40.000 Lesevorgänge pro Sekunde erreichen.
Informationen zur Schätzung des Lese- und Schreibkapazitätsverbrauchs einer Tabelle finden Sie unter[Schätzen Sie den Kapazitätsverbrauch des Lese- und Schreibdurchsatzes in Amazon Keyspaces](capacity-examples.md).
Weitere Informationen zu Standardkontingenten für Ihr Konto und deren Erhöhung finden Sie unter[Kontingente für Amazon Keyspaces (für Apache Cassandra)](quotas.md).
## Anfänglicher Durchsatz für den On-Demand-Kapazitätsmodus
Wenn Sie eine neue Tabelle mit aktiviertem On-Demand-Kapazitätsmodus erstellen oder eine bestehende Tabelle zum ersten Mal in den On-Demand-Kapazitätsmodus wechseln, weist die Tabelle die folgenden vorherigen Spitzeneinstellungen auf, obwohl sie zuvor keinen Datenverkehr im On-Demand-Kapazitätsmodus bedient hat:
+ **Neu erstellte Tabelle mit On-Demand-Kapazitätsmodus:** Die bisherigen Spitzenwerte lagen bei 2.000 WRUs und 6.000 RRUs. Sie können sofort bis zum Doppelten des vorherigen Spitzenwerts fahren. Auf diese Weise können neu erstellte On-Demand-Tabellen bis zu 4.000 WRUs und 12.000 Personen RRUs bedienen.
+ **Bestehende Tabelle wurde in den On-Demand-Kapazitätsmodus umgeschaltet: Die vorherige Spitzenleistung** ist halb so hoch wie die vorherige WCUs und wurde für die Tabelle oder die Einstellungen für eine neu erstellte Tabelle mit On-Demand-Kapazitätsmodus RCUs bereitgestellt, je nachdem, welcher Wert höher ist.
# Konfigurieren Sie den Modus für bereitgestellte Kapazität
Wenn Sie den Modus „*Bereitgestellte Durchsatzkapazität*“ wählen, geben Sie die Anzahl der Lese- und Schreibvorgänge pro Sekunde an, die für Ihre Anwendung erforderlich sind. Auf diese Weise können Sie Ihre Amazon Keyspaces-Nutzung so verwalten, dass sie bei oder unter einer definierten Anforderungsrate bleibt, um die Vorhersehbarkeit zu gewährleisten. Weitere Informationen zur automatischen Skalierung für den bereitgestellten Durchsatz finden Sie unter. [Automatische Verwaltung der Durchsatzkapazität mit Amazon Keyspaces Auto Scaling](autoscaling.md)
Der Kapazitätsmodus für bereitgestellten Durchsatz ist eine gute Option, wenn eine der folgenden Bedingungen zutrifft:
+ Der Datenverkehr Ihrer Anwendung ist berechenbar.
+ Sie führen Anwendungen aus, deren Datenverkehr konsistent ist oder allmählich ansteigt.
+ Sie können den Kapazitätsbedarf prognostizieren.
## Lesekapazitätseinheiten und Schreibkapazitätseinheiten
Für bereitgestellte Durchsatzkapazitätsmodus-Tabellen geben Sie die Durchsatzkapazität in Form von Lesekapazitätseinheiten (RCUs) und Schreibkapazitätseinheiten (WCUs) an:
+ Eine *RCU* entspricht einem `LOCAL_QUORUM` Lesevorgang pro Sekunde oder zwei `LOCAL_ONE` Lesevorgängen pro Sekunde für eine Zeile mit einer Größe von bis zu 4 KB. Wenn Sie eine Zeile lesen müssen, die größer als 4 KB ist, verwendet der Lesevorgang zusätzliche RCUs Daten.
Die Gesamtzahl der RCUs erforderlichen Daten hängt von der Zeilengröße ab und davon, ob Sie lesen möchten `LOCAL_QUORUM` oder `LOCAL_ONE` lesen möchten. Wenn Ihre Zeilengröße beispielsweise 8 KB beträgt, benötigen Sie 2, RCUs um einen `LOCAL_QUORUM` Lesevorgang pro Sekunde durchzuführen, und 1 RCU, wenn Sie `LOCAL_ONE` Lesevorgänge wählen.
+ Eine *WCU* entspricht einem Schreibvorgang pro Sekunde für eine Zeile mit einer Größe von bis zu 1 KB. Bei allen Schreibvorgängen wird `LOCAL_QUORUM` Konsistenz verwendet, und es fallen keine zusätzlichen Gebühren für die Verwendung von Lightweight Transactions (LWTs) an. Wenn Sie eine Zeile schreiben müssen, die größer als 1 KB ist, verwendet der Schreibvorgang zusätzliche Daten WCUs.
Die Gesamtzahl der WCUs erforderlichen Dateien hängt von der Zeilengröße ab. Wenn Ihre Zeilengröße beispielsweise 2 KB beträgt, benötigen Sie 2, WCUs um eine Schreibanforderung pro Sekunde aufrechtzuerhalten. Weitere Hinweise zur Schätzung des Lese- und Schreibkapazitätsverbrauchs einer Tabelle finden Sie unter[Schätzen Sie den Kapazitätsverbrauch des Lese- und Schreibdurchsatzes in Amazon Keyspaces](capacity-examples.md).
Wenn Ihre Anwendung größere Zeilen liest oder schreibt (bis zur maximalen Zeilengröße von Amazon Keyspaces von 1 MB), verbraucht sie mehr Kapazitätseinheiten. Weitere Informationen zur Schätzung der Zeilengröße finden Sie unter. [Schätzen Sie die Zeilengröße in Amazon Keyspaces](calculating-row-size.md) Nehmen wir beispielsweise an, Sie erstellen eine bereitgestellte Tabelle mit 6 RCUs und 6. WCUs Mit diesen Einstellungen hat Ihre Anwendung folgende Möglichkeiten:
+ Führen Sie `LOCAL_QUORUM` Lesevorgänge mit bis zu 24 KB pro Sekunde (4 KB × 6 RCUs) durch.
+ Führen Sie `LOCAL_ONE` Lesevorgänge mit bis zu 48 KB pro Sekunde durch (doppelt so viel Lesedurchsatz).
+ Schreiben Sie bis zu 6 KB pro Sekunde (1 KB × 6 WCUs).
Der *bereitgestellte Durchsatz* ist die maximale Menge an Durchsatzkapazität, die eine Anwendung aus einer Tabelle verbrauchen kann. Wenn Ihre Anwendung die bereitgestellte Durchsatzkapazität überschreitet, treten möglicherweise Fehler bei unzureichender Kapazität auf.
Beispielsweise schlägt eine Leseanforderung, die nicht über genügend Durchsatzkapazität verfügt, mit einer `Read_Timeout` Ausnahme fehl und wird der `ReadThrottleEvents` Metrik zugewiesen. Eine Schreibanforderung, die nicht über genügend Durchsatzkapazität verfügt, schlägt mit einer `Write_Timeout` Ausnahme fehl und wird der `WriteThrottleEvents` Metrik zugewiesen.
Sie können Amazon verwenden CloudWatch , um Ihre bereitgestellten und tatsächlichen Durchsatzmetriken sowie Ereignisse mit unzureichender Kapazität zu überwachen. Weitere Informationen zu diesen Metriken finden Sie unter [Amazon Keyspaces-Metriken und -Dimensionen](metrics-dimensions.md).
**Anmerkung**
Wiederholte Fehler aufgrund unzureichender Kapazität können zu clientseitigen treiberspezifischen Ausnahmen führen, z. B. schlägt der DataStax Java-Treiber mit einem fehl. `NoHostAvailableException`
Um die Durchsatzkapazitätseinstellungen für Tabellen zu ändern, können Sie die Anweisung AWS-Managementkonsole oder die `ALTER TABLE` Anweisung mithilfe von CQL verwenden. Weitere Informationen finden Sie unter. [ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter)
Weitere Informationen zu Standardkontingenten für Ihr Konto und deren Erhöhung finden Sie unter[Kontingente für Amazon Keyspaces (für Apache Cassandra)](quotas.md).
# Den Kapazitätsmodus einer Tabelle in Amazon Keyspaces anzeigen
Sie können die Systemtabelle im Amazon Keyspaces-Systemschlüsselraum abfragen, um Informationen zum Kapazitätsmodus einer Tabelle zu überprüfen. Sie können auch sehen, ob eine Tabelle den On-Demand-Durchsatzkapazitätsmodus oder den bereitgestellten Durchsatzkapazitätsmodus verwendet. Wenn die Tabelle mit dem Modus „Bereitgestellte Durchsatzkapazität“ konfiguriert ist, können Sie die für die Tabelle bereitgestellte Durchsatzkapazität sehen.
Sie können den auch verwenden AWS CLI , um den Kapazitätsmodus einer Tabelle anzuzeigen.
Informationen zum Ändern des bereitgestellten Durchsatzes einer Tabelle finden Sie unter[Ändern Sie den Kapazitätsmodus einer Tabelle in Amazon Keyspaces](ReadWriteCapacityMode.SwitchReadWriteCapacityMode.md).
------
#### [ Cassandra Query Language (CQL) ]
**Beispiel**
```
SELECT * from system_schema_mcs.tables where keyspace_name = 'mykeyspace' and table_name = 'mytable';
```
Eine Tabelle, die mit dem On-Demand-Kapazitätsmodus konfiguriert ist, gibt Folgendes zurück.
```
{
"capacity_mode":{
"last_update_to_pay_per_request_timestamp":"1579551547603",
"throughput_mode":"PAY_PER_REQUEST"
}
}
```
Eine mit dem Modus „Bereitgestellte Durchsatzkapazität“ konfigurierte Tabelle gibt Folgendes zurück.
```
{
"capacity_mode":{
"last_update_to_pay_per_request_timestamp":"1579048006000",
"read_capacity_units":"5000",
"throughput_mode":"PROVISIONED",
"write_capacity_units":"6000"
}
}
```
Der `last_update_to_pay_per_request_timestamp` Wert wird in Millisekunden gemessen.
------
#### [ CLI ]
Zeigen Sie den Durchsatzkapazitätsmodus einer Tabelle an, indem Sie AWS CLI
```
aws keyspaces get-table --keyspace-name myKeyspace --table-name myTable
```
Die Ausgabe des Befehls kann für eine Tabelle im Modus für bereitgestellte Kapazität ähnlich aussehen.
```
"capacitySpecification": {
"throughputMode": "PROVISIONED",
"readCapacityUnits": 4000,
"writeCapacityUnits": 2000
}
```
Die Ausgabe für eine Tabelle im On-Demand-Modus sieht wie folgt aus.
```
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST",
"lastUpdateToPayPerRequestTimestamp": "2024-10-03T10:48:19.092000+00:00"
}
```
------
# Ändern Sie den Kapazitätsmodus einer Tabelle in Amazon Keyspaces
Wenn Sie eine Tabelle vom Bereitstellungskapazitätsmodus in den On-Demand-Kapazitätsmodus wechseln, nimmt Amazon Keyspaces mehrere Änderungen an der Struktur Ihrer Tabelle und Partitionen vor. Dieser Vorgang kann einige Minuten dauern. Während der Umstellungsphase liefert Ihre Tabelle einen Durchsatz, der den zuvor bereitgestellten WCU- und RCU-Mengen entspricht.
Wenn Sie vom On-Demand-Kapazitätsmodus zurück in den Modus mit bereitgestellter Kapazität wechseln, liefert Ihre Tabelle einen Durchsatz, der dem vorherigen Spitzenwert entspricht, der erreicht wurde, als die Tabelle in den On-Demand-Kapazitätsmodus versetzt wurde.
Beim Umschalten zwischen den Kapazitätsmodi gelten die folgenden Wartezeiten:
+ Sie können eine neu erstellte Tabelle im On-Demand-Modus jederzeit in den Modus für bereitgestellte Kapazität umschalten. Sie können sie jedoch erst 24 Stunden nach dem Erstellungszeitstempel der Tabelle wieder in den On-Demand-Modus zurückschalten.
+ Sie können eine bestehende Tabelle im On-Demand-Modus jederzeit in den Modus für bereitgestellte Kapazität umschalten. Sie können den Kapazitätsmodus jedoch nur einmal innerhalb von 24 Stunden vom Bereitstellungs- zum On-Demand-Modus wechseln.
------
#### [ Cassandra Query Language (CQL) ]
**Ändern Sie den Durchsatzkapazitätsmodus einer Tabelle mithilfe von CQL**
1. Um den Kapazitätsmodus einer Tabelle in zu ändern, müssen `PROVIOSIONED` Sie die Lese- und Schreibkapazitätseinheiten auf der Grundlage der erwarteten Spitzenwerte Ihrer Workloads konfigurieren. Die folgende Aussage ist ein Beispiel dafür. Sie können diese Anweisung auch ausführen, um die Lese- oder Schreibkapazitätseinheiten der Tabelle anzupassen.
```
ALTER TABLE catalog.book_awards WITH CUSTOM_PROPERTIES={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 6000, 'write_capacity_units': 3000}};
```
Informationen zur Konfiguration des Modus für bereitgestellte Kapazität mit auto-scaling finden Sie unter. [Konfigurieren Sie die automatische Skalierung für eine bestehende Tabelle](autoscaling.configureTable.md)
1. Um den Kapazitätsmodus einer Tabelle in den On-Demand-Modus zu ändern, stellen Sie den Durchsatzmodus auf ein. `PAY_PER_REQUEST` Die folgende Aussage ist ein Beispiel dafür.
```
ALTER TABLE catalog.book_awards WITH CUSTOM_PROPERTIES={'capacity_mode':{'throughput_mode': 'PAY_PER_REQUEST'}};
```
1. Sie können die folgende Anweisung verwenden, um den Kapazitätsmodus der Tabelle zu bestätigen.
```
SELECT * from system_schema_mcs.tables where keyspace_name = 'catalog' and table_name = 'book_awards';
```
Eine Tabelle, die mit dem On-Demand-Kapazitätsmodus konfiguriert ist, gibt Folgendes zurück.
```
{
"capacity_mode":{
"last_update_to_pay_per_request_timestamp":"1727952499092",
"throughput_mode":"PAY_PER_REQUEST"
}
}
```
Der `last_update_to_pay_per_request_timestamp` Wert wird in Millisekunden gemessen.
------
#### [ CLI ]
**Ändern Sie den Durchsatzkapazitätsmodus einer Tabelle mit dem AWS CLI**
1. Um den Kapazitätsmodus der Tabelle auf zu ändern, müssen `PROVIOSIONED` Sie die Lese- und Schreibkapazitätseinheiten auf der Grundlage der erwarteten Spitzenwerte Ihrer Arbeitslast konfigurieren. Der folgende Befehl ist ein Beispiel dafür. Sie können diesen Befehl auch ausführen, um die Lese- oder Schreibkapazitätseinheiten der Tabelle anzupassen.
```
aws keyspaces update-table --keyspace-name catalog --table-name book_awards
\--capacity-specification throughputMode=PROVISIONED,readCapacityUnits=6000,writeCapacityUnits=3000
```
Informationen zur Konfiguration des Modus für bereitgestellte Kapazität mit auto-scaling finden Sie unter. [Konfigurieren Sie die automatische Skalierung für eine bestehende Tabelle](autoscaling.configureTable.md)
1. Um den Kapazitätsmodus einer Tabelle in den On-Demand-Modus zu ändern, stellen Sie den Durchsatzmodus auf ein. `PAY_PER_REQUEST` Die folgende Aussage ist ein Beispiel dafür.
```
aws keyspaces update-table --keyspace-name catalog --table-name book_awards
\--capacity-specification throughputMode=PAY_PER_REQUEST
```
1. Sie können den folgenden Befehl verwenden, um den Kapazitätsmodus zu überprüfen, der für eine Tabelle konfiguriert ist.
```
aws keyspaces get-table --keyspace-name catalog --table-name book_awards
```
Die Ausgabe für eine Tabelle im On-Demand-Modus sieht wie folgt aus.
```
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST",
"lastUpdateToPayPerRequestTimestamp": "2024-10-03T10:48:19.092000+00:00"
}
```
------
# Vorwärmung für Tabellen in Amazon Keyspaces konfigurieren
Amazon Keyspaces skaliert Speicherpartitionen automatisch auf der Grundlage des On-Demand-Durchsatzes oder des bereitgestellten Durchsatzes. Bei neuen Tabellen oder plötzlichen Durchsatzspitzen kann es jedoch länger dauern, bis die erforderlichen Speicherpartitionen zugewiesen sind. *Um sicherzustellen, dass eine neue oder bestehende Tabelle über genügend Kapazität verfügt, um den erwarteten Spitzendurchsatz zu unterstützen, können Sie manuell bestimmte Werte für den *Warmdurchsatz festlegen, um Ihre Tabelle vorzuwärmen*.*
Der *warme Durchsatz* bezieht sich auf die Anzahl der Lese- und Schreibvorgänge, die Ihre Amazon Keyspaces-Tabelle sofort unterstützen kann. Diese Werte sind standardmäßig für alle neuen und vorhandenen Tabellen verfügbar. Wenn Sie den On-Demand-Modus verwenden oder Ihren bereitgestellten Durchsatz aktualisieren, stellt Amazon Keyspaces sicher, dass Ihre Anwendung Anfragen bis zu diesen Werten sofort ausgeben kann.
Amazon Keyspaces passt die Warmdurchsatzwerte automatisch an, wenn Ihre Nutzung zunimmt. Um die Durchsatzkapazität an bevorstehende Spitzenereignisse anzupassen, z. B. wenn Sie Daten aus einer anderen Datenbank migrieren, was das Laden von Terabyte an Daten in kurzer Zeit erfordern kann, können Sie die Warmdurchsatzwerte Ihrer Tabellen manuell erhöhen. Dies ist nützlich für geplante Spitzenereignisse, bei denen die Anforderungsraten um das Zehnfache, das Hundertfache oder mehr steigen könnten. Prüfen Sie zunächst, ob der aktuelle Durchsatz im Warmbetrieb ausreicht, um den erwarteten Verkehr zu bewältigen. Wenn Sie dann die Tabelle für die geplante Spitzenauslastung vorwärmen müssen, können Sie den Wert für den Warmdurchsatz manuell erhöhen, ohne Ihre Durchsatzeinstellungen oder den [Kapazitätsmodus](ReadWriteCapacityMode.md) zu ändern.
Sie können Tabellen für Lesevorgänge, Schreibvorgänge oder beides vorwärmen. Sie können diesen Wert für neue und bestehende Tabellen mit einer Region und Tabellen mit mehreren Regionen erhöhen. Die von Ihnen festgelegten Einstellungen für den Warmdurchsatz gelten dann automatisch für alle Replikate der Tabellen mit mehreren Regionen. Die Anzahl der Amazon Keyspaces-Tabellen, die Sie jederzeit vorwärmen können, ist unbegrenzt. Die Zeit bis zum Abschluss des Vorwärmens hängt von den von Ihnen eingestellten Werten und der Größe des Tisches ab. Sie können gleichzeitig Anfragen zum Vorwärmen einreichen, ohne dass diese Anfragen den Betrieb der Tabelle beeinträchtigen. Sie können Ihren Tisch vorwärmen, bis das Tischkontingentlimit für Ihr Konto in dieser Region erreicht ist. Verwenden Sie die [Service Quotas Quotas-Konsole](https://console.aws.amazon.com/servicequotas), um Ihre aktuellen Kontingente zu überprüfen und sie bei Bedarf zu erhöhen.
Die Warmdurchsatzwerte, die Amazon Keyspaces auf der Grundlage Ihrer On-Demand-Nutzung oder der bereitgestellten Kapazität anpasst, sind standardmäßig für alle Tabellen ohne zusätzliche Gebühren verfügbar. Wenn Sie jedoch die Standardwerte für den Warmdurchsatz manuell auf Tabellen für die Vorwärmphase für Ereignisse mit hohem Verkehrsaufkommen erhöhen, fallen zusätzliche Gebühren an. Weitere Informationen finden Sie unter [Amazon Keyspaces-Preise](https://aws.amazon.com/keyspaces/pricing/).
Im Folgenden finden Sie einige verschiedene Szenarien und bewährte Methoden, die Sie beim Vorwärmen von Amazon Keyspaces-Tabellen berücksichtigen könnten.
## Warmdurchsatz und ungleiche Zugriffsmuster
Eine Tabelle kann einen warmen Durchsatz von 30.000 Leseeinheiten pro Sekunde und 10.000 Schreibeinheiten pro Sekunde haben, aber es kann trotzdem zu Kapazitätsüberschreitungen bei Lese- oder Schreibvorgängen kommen, bevor diese Werte erreicht werden. Das liegt wahrscheinlich an einer Hot-Partition. Amazon Keyspaces kann zwar weiter skaliert werden, um praktisch unbegrenzten Durchsatz zu unterstützen, aber jede einzelne Partition ist auf 1.000 Schreibeinheiten pro Sekunde und 3.000 Leseeinheiten pro Sekunde begrenzt. Wenn Ihre Anwendung zu viel Traffic auf einen kleinen Teil der Tabellenpartitionen lenkt, kann es zu Kapazitätsüberschreitungen kommen, noch bevor Sie die warmen Durchsatzwerte der Tabelle erreichen. Wir empfehlen, die [Best Practices von Amazon Keyspaces](bp-partition-key-design.md) zu befolgen, um eine nahtlose Skalierbarkeit zu gewährleisten und heiße Partitionen zu vermeiden.
## Warmdurchsatz für eine bereitgestellte Tabelle
Stellen Sie sich eine bereitgestellte Tabelle vor, die einen Warm-Durchsatz von 30.000 Leseeinheiten pro Sekunde und 10.000 Schreibeinheiten pro Sekunde hat, derzeit jedoch einen bereitgestellten Durchsatz von 4.000 RCUs und 8.000 aufweist. WCUs Sie können den bereitgestellten Durchsatz der Tabelle sofort auf bis zu 30.000 RCUs oder 10.000 skalieren, WCUs indem Sie Ihre Einstellungen für den bereitgestellten Durchsatz aktualisieren. Wenn Sie den bereitgestellten Durchsatz über diese Werte hinaus erhöhen, passt sich der warme Durchsatz automatisch an die neuen höheren Werte an, da Sie einen neuen Spitzendurchsatz festgelegt haben. Wenn Sie beispielsweise den bereitgestellten Durchsatz auf 50.000 RCU festlegen, steigt der Durchsatz im Warmbetrieb auf 50.000 Leseeinheiten pro Sekunde.
```
"ProvisionedThroughput":
{
"ReadCapacityUnits": 4000,
"WriteCapacityUnits": 8000
}
"WarmThroughput":
{
"ReadUnitsPerSecond": 30000,
"WriteUnitsPerSecond": 10000
}
```
## Warmdurchsatz für eine On-Demand-Tabelle
Eine neue On-Demand-Tabelle beginnt mit einem Warmdurchsatz von 12 000 Leseeinheiten pro Sekunde und 4 000 Schreibeinheiten pro Sekunde. Ihre Tabelle kann anhaltenden Datenverkehr bis zu diesen Werten sofort verarbeiten. Wenn Ihre Anfragen 12.000 Leseeinheiten pro Sekunde oder 4.000 Schreibeinheiten pro Sekunde überschreiten, passt sich der Warmdurchsatz automatisch an die höheren Werte an.
```
"WarmThroughput":
{
"ReadUnitsPerSecond": 12000,
"WriteUnitsPerSecond": 4000
}
```
## Bewährte Methoden für das Vorwärmen von Amazon Keyspaces-Tabellen
Folgen Sie diesen bewährten Methoden, wenn Sie Pre-Warming für Ihre Amazon Keyspaces-Tabellen implementieren:
Schätzen Sie die benötigte Kapazität genau ab
Da das Vorwärmen mit einmaligen Kosten verbunden ist, sollten Sie den benötigten Durchsatz anhand der zu erwartenden Arbeitslast sorgfältig berechnen, um eine übermäßige Bereitstellung zu vermeiden.
Betrachten Sie das Schema der Tabelle
Tabellen mit größeren Zeilen benötigen möglicherweise mehr Partitionen für denselben Durchsatz. Berücksichtigen Sie bei der Schätzung des Bedarfs vor der Erwärmung Ihre durchschnittliche Zeilengröße.
Überwachen Sie die Tabellenleistung
Überprüfen Sie nach dem Vorwärmen anhand von CloudWatch Messwerten, ob Ihre Tabelle die Last erwartungsgemäß bewältigt. Weitere Informationen finden Sie unter [Überwachen Sie die Leistung eines vorgewärmten Tisches mit Amazon CloudWatch](monitor-prewarming-cloudwatch.md).
Kontingente verwalten
Wenn Ihre Anwendung einen höheren Durchsatz benötigt, als es die Standardkontingente zulassen (40.000 RCUs/WCUs oder 2.000 Partitionen), wird das Anforderungskontingent rechtzeitig vor dem Ereignis mit hohem Datenaufkommen erhöht. Zum Anfordern einer Erhöhung für ein Kontingent können Sie die [Service-Quotas-Konsole](https://console.aws.amazon.com/servicequotas) verwenden.
Optimieren Sie die Kosten
Bei vorübergehenden Ereignissen mit hohem Datenaufkommen sollten Sie die Verwendung von Pre-Warming in Betracht ziehen, anstatt in den Bereitstellungsmodus mit hoher Kapazität zu wechseln, da dies für Ereignisse mit kurzer Dauer kostengünstiger sein kann. Weitere Informationen zur Preisgestaltung finden Sie unter [Amazon Keyspaces-Preise](https://aws.amazon.com/keyspaces/pricing/).
**Anmerkung**
Überwachen Sie die Leistungskennzahlen Ihrer Anwendung während der Testphase, um sicherzustellen, dass Ihre Pre-Warming-Konfiguration Ihre Workload-Anforderungen angemessen unterstützt.
**Topics**
+ [
## Warmdurchsatz und ungleiche Zugriffsmuster
](#warm-throughput-scenarios-uneven)
+ [
## Warmdurchsatz für eine bereitgestellte Tabelle
](#warm-throughput-scenarios-provisioned)
+ [
## Warmdurchsatz für eine On-Demand-Tabelle
](#warm-throughput-scenarios-ondemand)
+ [
## Bewährte Methoden für das Vorwärmen von Amazon Keyspaces-Tabellen
](#prewarming-best-practices)
+ [
# Erstellen einer neuen Amazon-Keyspaces-Tabelle mit einem höheren Warmdurchsatz
](create-table-warm-throughput.md)
+ [
# Erhöhen des Warmdurchsatzes für die vorhandene Amazon-Keyspaces-Tabelle
](update-warm-throughput.md)
+ [
# Warmdurchsatz einer Amazon Keyspaces-Tabelle anzeigen
](view-warm-throughput.md)
+ [
# Überwachen Sie die Leistung eines vorgewärmten Tisches mit Amazon CloudWatch
](monitor-prewarming-cloudwatch.md)
# Erstellen einer neuen Amazon-Keyspaces-Tabelle mit einem höheren Warmdurchsatz
Sie können die Warmdurchsatzwerte anpassen, wenn Sie Ihre Amazon Keyspaces-Tabelle mithilfe der Konsole, CQL oder der erstellen. AWS CLI
------
#### [ Console ]
**So erstellen Sie eine neue Tabelle mit Warmdurchsatzeinstellungen**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon Keyspaces-Konsole zu [https://console.aws.amazon.com/keyspaces/Hause](https://console.aws.amazon.com/keyspaces/home).
1. Wählen Sie im Navigationsbereich **Tables** (Tabellen) und anschließend **Create table** (Tabelle erstellen) aus.
1. Wählen Sie auf der Seite **Tabelle erstellen** im Abschnitt **Tabellendetails** einen Schlüsselraum aus und geben Sie einen Namen für die neue Tabelle ein.
1. Erstellen Sie im Abschnitt **Spalten** das Schema für Ihre Tabelle.
1. Definieren Sie im Abschnitt **Primärschlüssel** den Primärschlüssel der Tabelle und wählen Sie optionale Clusterspalten aus.
1. Wählen Sie im Abschnitt **Tabelleneinstellungen** die Option **Einstellungen anpassen** aus.
1. Fahren Sie mit den **Lese-/Schreibkapazitätseinstellungen** fort.
1. **Für den **Kapazitätsmodus** können Sie entweder „Auf **Abruf**“ oder „Bereitgestellt“ wählen.**
1. Im Bereich **Vorwärmen für Tabellen** können Sie die Werte für **Leseeinheiten pro Sekunde und **Schreibeinheiten pro Sekunde**** nach Bedarf erhöhen, um Ihre Tabelle auf geplante Spitzenereignisse vorzubereiten.
Die Warmdurchsatzwerte, die Amazon Keyspaces auf der Grundlage Ihrer On-Demand-Nutzung oder der bereitgestellten Kapazität anpasst, sind standardmäßig für alle Tabellen ohne zusätzliche Gebühren verfügbar. Beachten Sie, dass zusätzliche Gebühren anfallen, wenn Sie die Standardwerte für den Warmdurchsatz manuell erhöhen, um die Tabelle für Ereignisse mit hohem Verkehrsaufkommen vorzuwärmen.
1. Konfigurieren Sie nach Bedarf weitere optionale Tabellenfunktionen. Wählen Sie dann **Tabelle erstellen aus**.
------
#### [ Cassandra Query Language (CQL) ]
+ Erstellen Sie mit einer der folgenden Methoden eine Tabelle mit warmem Durchsatz:
+ Erstellen Sie für den Bereitstellungsmodus eine Tabelle und geben Sie die erwartete Spitzenkapazität für Lese- und Schreibvorgänge mithilfe der folgenden CQL-Syntax an:
```
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
}
};
```
+ Erstellen Sie für den On-Demand-Modus eine Tabelle und geben Sie die erwartete Spitzenkapazität für Lese- und Schreibvorgänge mit der folgenden CQL-Syntax an:
```
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
}
};
```
Informationen zur Bestätigung der Kapazitätseinstellungen der Tabelle finden Sie unter[Warmdurchsatz einer Amazon Keyspaces-Tabelle anzeigen](view-warm-throughput.md).
------
#### [ CLI ]
1. Erstellen Sie eine Tabelle mit warmem Durchsatz mit einer der folgenden Methoden unter Verwendung von AWS CLI
+ Erstellen Sie eine neue Tabelle im Bereitstellungsmodus und geben Sie die erwarteten Spitzenkapazitätswerte für Lese- und Schreibvorgänge für die neue Tabelle an. Die folgende Aussage ist ein Beispiel dafür.
```
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
```
+ Erstellen Sie eine neue Tabelle im On-Demand-Modus und geben Sie die erwarteten Spitzenkapazitätswerte für Lese- und Schreibvorgänge für die neue Tabelle an. Die folgende Aussage ist ein Beispiel dafür.
```
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. Die Ausgabe des Befehls gibt den ARN der Tabelle zurück, wie im folgenden Beispiel gezeigt.
```
{
"resourceArn": "arn:aws::cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards>"
}
```
Informationen zur Bestätigung der Kapazitätseinstellungen der Tabelle finden Sie unter[Warmdurchsatz einer Amazon Keyspaces-Tabelle anzeigen](view-warm-throughput.md).
------
#### [ Java ]
**Erstellen Sie eine neue Tabelle mit dem SDK for Java.**
+ Erstellen Sie eine neue Tabelle im Bereitstellungsmodus und geben Sie die erwarteten Spitzenkapazitätswerte für Lese- und Schreibvorgänge für die neue Tabelle an. Das folgende Codebeispiel ist ein Beispiel dafür.
```
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());
}
}
```
------
# Erhöhen des Warmdurchsatzes für die vorhandene Amazon-Keyspaces-Tabelle
Sie können die aktuellen Warmdurchsatzwerte Ihrer Amazon Keyspaces-Tabelle mithilfe der Konsole, CQL oder der erhöhen. AWS CLI
------
#### [ Console ]
**So erhöhen Sie die Vorwärmeinstellungen einer Tabelle mithilfe der Konsole**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon Keyspaces-Konsole zu [https://console.aws.amazon.com/keyspaces/Hause](https://console.aws.amazon.com/keyspaces/home).
1. Wählen Sie im Navigationsbereich **Tabellen** und dann die Tabelle aus, die Sie aktualisieren möchten.
1. Fahren Sie in der Tabelle auf der Registerkarte **Kapazität** mit dem Abschnitt **Vorwärmen für Tische** fort.
1. **Wählen Sie im Abschnitt **Vorwärmen für Tabellen die** Option Bearbeiten aus.**
1. Auf der Seite **Vorwärmung für Tabellen bearbeiten** können Sie die Werte für **Leseeinheiten pro Sekunde** und für **Schreibeinheiten pro** Sekunde aktualisieren.
1. Wählen Sie **Änderungen speichern ** aus. Ihre Tabelle wird mit den angegebenen Vorwärmeinstellungen aktualisiert.
------
#### [ Cassandra Query Language (CQL) ]
**Erhöhen Sie die Warmdurchsatzeinstellungen einer Tabelle mithilfe von CQL**
+ Verwenden Sie die `ALTER TABLE` Anweisung, um den Warmdurchsatz einer Tabelle zu erhöhen. Die folgende Aussage ist ein Beispiel dafür.
```
ALTER TABLE catalog.book_awards
WITH CUSTOM_PROPERTIES = {
'warm_throughput': {
'read_units_per_second': 60000,
'write_units_per_second': 30000
}
};
```
Informationen zur Bestätigung der aktualisierten Kapazitätseinstellungen der Tabelle finden Sie unter[Warmdurchsatz einer Amazon Keyspaces-Tabelle anzeigen](view-warm-throughput.md).
------
#### [ CLI ]
**Erhöhen Sie die Vorwärmeinstellungen eines Tisches mithilfe der AWS CLI**
+ Um den Warmdurchsatz einer Tabelle zu erhöhen, können Sie den Befehl verwenden. `update-table` Die folgende Aussage ist ein Beispiel dafür.
```
aws keyspaces update-table \
--keyspace-name 'catalog' \
--table-name 'book_awards' \
--warmThroughputSpecification readUnitsPerSecond=60000,writeUnitsPerSecond=30000
```
Informationen zur Bestätigung der aktualisierten Kapazitätseinstellungen der Tabelle finden Sie unter[Warmdurchsatz einer Amazon Keyspaces-Tabelle anzeigen](view-warm-throughput.md).
------
#### [ Java ]
**Aktualisieren Sie die Vorwärmeinstellungen einer Tabelle mithilfe des SDK for Java.**
+ Aktualisieren Sie die Warmdurchsatzeinstellungen für eine Tabelle. Das folgende Codebeispiel ist ein Beispiel dafür.
```
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());
}
}
```
------
# Warmdurchsatz einer Amazon Keyspaces-Tabelle anzeigen
Sie können die aktuellen Warmdurchsatzwerte Ihrer Amazon Keyspaces-Tabelle mit der Konsole, CQL oder dem anzeigen. AWS CLI
------
#### [ Console ]
**So zeigen Sie die Vorwärmeinstellungen Ihres Tisches mithilfe der Konsole an.**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon Keyspaces-Konsole zu [https://console.aws.amazon.com/keyspaces/Hause](https://console.aws.amazon.com/keyspaces/home).
1. Wählen Sie im Navigationsbereich **Tabellen** und dann die Tabelle aus, die Sie überprüfen möchten.
1. Fahren Sie in der Tabelle auf der Registerkarte **Kapazität** mit dem Abschnitt **Vorwärmen für Tische** fort.
------
#### [ Cassandra Query Language (CQL) ]
**Zeigen Sie mithilfe von CQL die Warmdurchsatzeinstellungen einer Tabelle an**
+ Um die Warmdurchsatzeinstellungen einer Tabelle anzuzeigen, können Sie die folgende CQL-Anweisung verwenden.
```
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 ]
**Zeigen Sie die Warmdurchsatz-Einstellungen einer Tabelle mit dem AWS CLI**
+ Sie können die Warmdurchsatz-Einstellungen einer Tabelle mithilfe des `get-table` Befehls anzeigen, wie im folgenden Beispiel gezeigt.
```
aws keyspaces get-table \
--keyspace-name 'catalog' \
--table-name 'book_awards'
```
Im Folgenden wird die Beispielausgabe des `get-table` Befehls für eine Tabelle mit nur einer Region im Bereitstellungsmodus gezeigt.
```
{
"keyspaceName": "catalog",
"tableName": "book_awards",
... Existing Fields ...,
"capacitySpecificationSummary": {
"throughputMode": "PROVISIONED",
"readCapacityUnits": 20000,
"writeCapacityUnits": 10000
},
"warmThroughputSpecificationSummary": {
"readUnitsPerSecond": 40000,
"writeUnitsPerSecond": 20000,
"status": "AVAILABLE"
}
}
```
Im Folgenden wird die Beispielausgabe für eine Tabelle mit einer einzigen Region im On-Demand-Modus gezeigt.
```
{
"keyspaceName": "catalog",
"tableName": "book_awards_ondemand",
... Existing Fields ...,
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST"
},
"warmThroughputSpecificationSummary": {
"readUnitsPerSecond": 40000,
"writeUnitsPerSecond": 20000,
"status": "AVAILABLE"
}
}
```
------
#### [ Java ]
**Lesen Sie die Vorwärmeinstellungen einer Tabelle mit dem SDK for Java.**
+ Lesen Sie die Warmdurchsatzwerte einer Tabelle mit. `get-table` Das folgende Codebeispiel ist ein Beispiel dafür.
```
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");
}
}
}
```
------
# Überwachen Sie die Leistung eines vorgewärmten Tisches mit Amazon CloudWatch
Amazon Keyspaces Pre-Warming führt keine neuen CloudWatch Metriken ein, aber Sie können die Leistung vorgewärmter Tabellen anhand vorhandener Amazon Keyspaces-Metriken überwachen:
SuccessfulRequestLatency
Überwachen Sie diese Metrik, um sicherzustellen, dass die vorgewärmte Tabelle Anfragen mit erwarteter Latenz verarbeitet.
WriteThrottleEvents und ReadThrottleEvents
Diese Messwerte sollten für eine ordnungsgemäß vorgewärmte Tabelle niedrig bleiben. Wenn Sie trotz Vorwärmen Fehler mit unzureichender Kapazität feststellen, müssen Sie möglicherweise Ihre Werte für den Warmdurchsatz anpassen.
ConsumedReadCapacityUnits und ConsumedWriteCapacityUnits
Diese Messwerte zeigen den tatsächlichen Kapazitätsverbrauch, sodass Sie überprüfen können, ob Ihre Vorwärmkonfiguration angemessen ist.
ProvisionedReadCapacityUnits und ProvisionedWriteCapacityUnits
Für bereitgestellte Tabellen zeigen diese Metriken die aktuell zugewiesene Kapazität.
Diese Metriken können in der CloudWatch Konsole angezeigt oder über die API abgefragt werden. CloudWatch Weitere Informationen finden Sie unter [Überwachung von Amazon Keyspaces mit Amazon CloudWatch](monitoring-cloudwatch.md).
# Automatische Verwaltung der Durchsatzkapazität mit Amazon Keyspaces Auto Scaling
Viele Datenbank-Workloads sind zyklischer Natur oder lassen sich nur schwer vorhersagen. Nehmen wir als Beispiel eine Social Networking-App, bei der die meisten Benutzer tagsüber aktiv sind. Die Datenbank muss in der Lage sein, die Aktivitäten am Tag zu verarbeiten, während in der Nacht nicht so viel Durchsatz erforderlich ist.
Ein weiteres Beispiel wäre eine neue Mobile Gaming-App, die sich schnell großer Beliebtheit erfreut. Wenn das Spiel sehr beliebt wird, könnte es die verfügbaren Datenbankressourcen überschreiten, was zu einer langsamen Leistung und unzufriedenen Kunden führen würde. Diese Arten von Workloads erfordern häufig manuelle Eingriffe, um die Datenbankressourcen nach oben oder unten zu skalieren, um sie an die jeweiligen Nutzungsschwankungen anzupassen.
Amazon Keyspaces (für Apache Cassandra) unterstützt Sie bei der effizienten Bereitstellung von Durchsatzkapazität für variable Workloads, indem die Durchsatzkapazität automatisch an den tatsächlichen Anwendungsverkehr angepasst wird. Amazon Keyspaces verwendet den Application Auto Scaling-Service, um die Lese- und Schreibkapazität einer Tabelle in Ihrem Namen zu erhöhen oder zu verringern. Weitere Informationen zu Application Auto Scaling finden Sie im [Application Auto Scaling Scaling-Benutzerhandbuch](https://docs.aws.amazon.com/autoscaling/application/userguide/).
**Anmerkung**
Informationen zum schnellen Einstieg in die automatische Skalierung von Amazon Keyspaces finden Sie unter[Automatische Skalierungsrichtlinien von Amazon Keyspace konfigurieren und aktualisieren](autoscaling.configure.md).
## So funktioniert die automatische Skalierung von Amazon Keyspace
Das folgende Diagramm bietet einen allgemeinen Überblick darüber, wie die automatische Skalierung von Amazon Keyspace die Durchsatzkapazität für eine Tabelle verwaltet.
![\[Ein Diagramm, das die verschiedenen Dienste zeigt, die beteiligt sind, wenn ein Benutzer eine Änderung an einer Amazon Keyspaces-Tabelle vornimmt. Bei den Diensten handelt es sich um Amazon CloudWatch, Amazon SNS und Application Auto Scaling, das die ALTER TABLE-Anweisung ausgibt, um die Kapazität basierend auf der Lese- oder Schreibnutzung des Benutzers zu ändern.\]](http://docs.aws.amazon.com/de_de/keyspaces/latest/devguide/images/keyspaces_auto-scaling.png)
Um die automatische Skalierung für eine Tabelle zu aktivieren, erstellen Sie eine *Skalierungsrichtlinie*. Die Skalierungsrichtlinie gibt an, ob die Lese- oder Schreibkapazität (oder beide) skaliert werden sollen, und enthält die Einstellungen für die minimalen und maximalen bereitgestellten Kapazitätseinheiten für die Tabelle.
Die Skalierungsrichtlinie definiert auch eine *Zielauslastung*. Die Zielauslastung bezeichnet das Verhältnis zwischen den verbrauchten Kapazitätseinheiten und den bereitgestellten Kapazitätseinheiten zu einem bestimmten Zeitpunkt. Sie wird als Prozentsatz angegeben. Die automatische Skalierung verwendet einen Algorithmus zur *Zielverfolgung*, um den bereitgestellten Durchsatz der Tabelle entsprechend den tatsächlichen Workloads nach oben oder unten anzupassen. Auf diese Weise wird sichergestellt, dass die tatsächliche Kapazitätsauslastung bei oder in der Nähe Ihrer Zielauslastung bleibt.
Sie können die Zielauslastung für die automatische Skalierung zwischen 20 und 90 Prozent für Ihre Lese- und Schreibkapazität festlegen. Die standardmäßige Zielauslastungsrate beträgt 70 Prozent. Sie können die Zielauslastung auf einen niedrigeren Prozentsatz festlegen, wenn sich Ihr Datenverkehr schnell ändert und Sie möchten, dass die Kapazität früher skaliert wird. Sie können die Zielauslastungsrate auch auf eine höhere Rate festlegen, wenn sich Ihr Anwendungsdatenverkehr langsamer ändert und Sie die Durchsatzkosten senken möchten.
Weitere Informationen zu Skalierungsrichtlinien finden Sie unter [Target-Tracking-Skalierungsrichtlinien für Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) im [https://docs.aws.amazon.com/autoscaling/application/userguide/](https://docs.aws.amazon.com/autoscaling/application/userguide/).
Wenn Sie eine Skalierungsrichtlinie erstellen, erstellt Amazon Keyspaces in Ihrem Namen zwei Paare von CloudWatch Amazon-Alarmen. Jedes Paar steht für Ihre Ober- und Untergrenzen für bereitgestellte und verbrauchte Durchsatzeinstellungen. Diese CloudWatch Alarme werden ausgelöst, wenn die tatsächliche Auslastung der Tabelle über einen längeren Zeitraum von Ihrer Zielauslastung abweicht. Weitere Informationen über Amazon CloudWatch finden Sie im [ CloudWatch Amazon-Benutzerhandbuch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).
Wenn einer der CloudWatch Alarme ausgelöst wird, sendet Ihnen Amazon Simple Notification Service (Amazon SNS) eine Benachrichtigung (sofern Sie ihn aktiviert haben). Der CloudWatch Alarm ruft dann Application Auto Scaling auf, um Ihre Skalierungsrichtlinie auszuwerten. Dies wiederum sendet eine Alter-Table-Anfrage an Amazon Keyspaces, um die bereitgestellte Kapazität der Tabelle nach Bedarf nach oben oder unten anzupassen. Weitere Informationen zu Amazon SNS SNS-Benachrichtigungen finden Sie unter [Amazon SNS SNS-Benachrichtigungen einrichten](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/US_SetupSNS.html).
Amazon Keyspaces verarbeitet die Alter-Table-Anfrage, indem es die bereitgestellte Durchsatzkapazität der Tabelle erhöht (oder verringert), sodass sie sich Ihrer Zielauslastung annähert.
**Anmerkung**
Amazon Keyspaces Auto Scaling ändert die bereitgestellten Durchsatzeinstellungen nur, wenn die tatsächliche Arbeitslast über einen längeren Zeitraum von mehreren Minuten erhöht (oder reduziert) bleibt. Der Ziel-Tracking-Algorithmus von versucht, dafür zu sorgen, dass die Zielauslastung langfristig Ihrem gewählten Wert (nahezu) entspricht. Plötzliche Aktivitätsspitzen werden von der integrierten Burst-Kapazität der Tabelle bewältigt.
## So funktioniert Auto Scaling für Tabellen mit mehreren Regionen
Um sicherzustellen, dass immer genügend Lese- und Schreibkapazität für alle Tabellenreplikate in einer Tabelle mit mehreren Regionen im Modus „Bereitgestellte Kapazität“ vorhanden ist, empfehlen wir Ihnen, Amazon Keyspaces Auto Scaling zu konfigurieren. AWS-Regionen
Wenn Sie eine Tabelle mit mehreren Regionen im Bereitstellungsmodus mit Auto Scaling verwenden, können Sie Auto Scaling nicht für ein einzelnes Tabellenreplikat deaktivieren. Sie können jedoch die Lese-Auto-Scaling-Einstellungen der Tabelle für verschiedene Regionen anpassen. Sie können beispielsweise für jede Region, in der die Tabelle repliziert wird, unterschiedliche Einstellungen für die Lesekapazität und das auto Skalieren von Lesevorgängen angeben.
Die Auto-Scaling-Leseeinstellungen, die Sie für ein Tabellenreplikat in einer bestimmten Region konfigurieren, überschreiben die allgemeinen Auto Scaling-Einstellungen der Tabelle. Die Schreibkapazität muss jedoch über alle Tabellenreplikate hinweg synchronisiert bleiben, um sicherzustellen, dass genügend Kapazität vorhanden ist, um Schreibvorgänge in allen Regionen zu replizieren.
Amazon Keyspaces Auto Scaling aktualisiert unabhängig die bereitgestellte Kapazität der Tabelle in jeder Tabelle auf der AWS-Region Grundlage der Nutzung in dieser Region. Daher kann die bereitgestellte Kapazität in jeder Region für eine Tabelle mit mehreren Regionen unterschiedlich sein, wenn Auto Scaling aktiv ist.
Sie können die Auto Scaling-Einstellungen einer Tabelle mit mehreren Regionen und ihren Replikaten mithilfe der Amazon Keyspaces-Konsole AWS CLI, API oder CQL konfigurieren. Weitere Informationen zum Erstellen und Aktualisieren von Auto Scaling-Einstellungen für Tabellen mit mehreren Regionen finden Sie unter[Aktualisieren Sie die bereitgestellten Kapazitäten und Auto-Scaling-Einstellungen für eine Tabelle mit mehreren Regionen in Amazon Keyspaces](tables-mrr-autoscaling.md).
**Anmerkung**
Wenn Sie Auto Scaling für Tabellen mit mehreren Regionen verwenden, müssen Sie immer Amazon Keyspaces-API-Operationen verwenden, um Auto-Scaling-Einstellungen zu konfigurieren. Wenn Sie die API-Operationen von Application Auto Scaling direkt verwenden, um Auto Scaling-Einstellungen zu konfigurieren, können Sie die AWS-Regionen Tabelle mit mehreren Regionen nicht angeben. Dies kann dazu führen, dass Konfigurationen nicht unterstützt werden.
## Nutzungshinweise
Bevor Sie mit der automatischen Skalierung von Amazon Keyspaces beginnen, sollten Sie Folgendes beachten:
+ Die automatische Skalierung von Amazon Keyspace ist in der Region Naher Osten (VAE) nicht verfügbar.
+ Die automatische Skalierung von Amazon Keyspace kann die Lese- oder Schreibkapazität gemäß Ihrer Skalierungsrichtlinie beliebig oft erhöhen. Alle Amazon Keyspaces-Kontingente bleiben in Kraft, wie unter beschrieben. [Kontingente für Amazon Keyspaces (für Apache Cassandra)](quotas.md)
+ Die automatische Skalierung von Amazon Keyspace verhindert nicht, dass Sie die bereitgestellten Durchsatzeinstellungen manuell ändern. Diese manuellen Anpassungen wirken sich nicht auf bestehende CloudWatch Alarme aus, die mit der Skalierungsrichtlinie verknüpft sind.
+ Wenn Sie die Konsole verwenden, um eine Tabelle mit bereitgestellter Durchsatzkapazität zu erstellen, ist die automatische Skalierung von Amazon Keyspace standardmäßig aktiviert. Sie können Ihre Einstellungen für die automatische Skalierung jederzeit ändern. Weitere Informationen finden Sie unter [auto Skalierung von Amazon Keyspaces für eine Tabelle ausschalten](autoscaling.turnoff.md).
+ Wenn Sie Skalierungsrichtlinien erstellen, sollten Sie die Skalierungsrichtlinien CloudFormation so verwalten, dass der Stack mit der Stack-Vorlage synchronisiert ist. CloudFormation Wenn Sie Skalierungsrichtlinien von Amazon Keyspaces ändern, werden diese beim Zurücksetzen des Stacks mit den Originalwerten aus der CloudFormation Stack-Vorlage überschrieben.
+ Wenn Sie CloudTrail die automatische Skalierung von Amazon Keyspaces überwachen, werden Ihnen möglicherweise Warnmeldungen für Aufrufe angezeigt, die von Application Auto Scaling im Rahmen des Konfigurationsvalidierungsprozesses getätigt wurden. Sie können diese Benachrichtigungen herausfiltern, indem Sie das `invokedBy` Feld verwenden, das `application-autoscaling.amazonaws.com` für diese Validierungsprüfungen enthält.
# Automatische Skalierungsrichtlinien von Amazon Keyspace konfigurieren und aktualisieren
Sie können die Konsole, CQL oder die AWS Command Line Interface (AWS CLI) verwenden, um die automatische Skalierung von Amazon Keyspaces für neue und bestehende Tabellen zu konfigurieren. Sie können auch die Einstellungen für die automatische Skalierung ändern oder die automatische Skalierung deaktivieren.
Für erweiterte Funktionen wie das Einstellen von Scale-In- und Scale-Out-Abklingzeiten empfehlen wir, dass Sie CQL oder die verwenden, um die Skalierungsrichtlinien von Amazon Keyspaces AWS CLI zu verwalten.
**Topics**
+ [
# Berechtigungen für die automatische Skalierung von Amazon Keyspaces konfigurieren
](autoscaling.permissions.md)
+ [
# Erstellen Sie eine neue Tabelle mit automatischer Skalierung
](autoscaling.createTable.md)
+ [
# Konfigurieren Sie die automatische Skalierung für eine bestehende Tabelle
](autoscaling.configureTable.md)
+ [
# Sehen Sie sich die Amazon Keyspaces-Auto-Scaling-Konfiguration Ihrer Tabelle an
](autoscaling.viewPolicy.md)
+ [
# auto Skalierung von Amazon Keyspaces für eine Tabelle ausschalten
](autoscaling.turnoff.md)
+ [
# Auto-Scaling-Aktivitäten für eine Amazon Keyspaces-Tabelle in Amazon anzeigen CloudWatch
](autoscaling.activity.md)
# Berechtigungen für die automatische Skalierung von Amazon Keyspaces konfigurieren
Stellen Sie zunächst sicher, dass der Principal über die entsprechenden Berechtigungen zum Erstellen und Verwalten von Einstellungen für die automatische Skalierung verfügt. In AWS Identity and Access Management (IAM) `AmazonKeyspacesFullAccess` ist die AWS verwaltete Richtlinie erforderlich, um die Skalierungsrichtlinien von Amazon Keyspaces zu verwalten.
**Wichtig**
`application-autoscaling:*`Berechtigungen sind erforderlich, um die automatische Skalierung für eine Tabelle zu deaktivieren. Sie müssen Auto Scaling für eine Tabelle deaktivieren, bevor Sie sie löschen können.
Um einen IAM-Benutzer oder eine IAM-Rolle für den Zugriff auf die Amazon Keyspaces-Konsole und die automatische Skalierung von Amazon Keyspaces einzurichten, fügen Sie die folgende Richtlinie hinzu.
**Um die Richtlinie anzuhängen `AmazonKeyspacesFullAccess`**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Wählen Sie im Dashboard der IAM-Konsole **Benutzer** und wählen Sie dann Ihren IAM-Benutzer oder Ihre IAM-Rolle aus der Liste aus.
1. Wählen Sie auf der Seite **Summary** (Übersicht) die Option **Add permissions** (Berechtigungen hinzufügen) aus.
1. Wählen Sie **Attach existing policies directly** (Vorhandene Richtlinien direkt zuordnen).
1. Wählen Sie **AmazonKeyspacesFullAccess**aus der Liste der Richtlinien die Option und anschließend **Weiter:** Überprüfen aus.
1. Wählen Sie **Add permissions** (Berechtigungen hinzufügen) aus.
# Erstellen Sie eine neue Tabelle mit automatischer Skalierung
Wenn Sie eine neue Amazon Keyspaces-Tabelle erstellen, können Sie automatisch Auto Scaling für die Schreib- oder Lesekapazität der Tabelle aktivieren. Dadurch kann Amazon Keyspaces in Ihrem Namen Application Auto Scaling kontaktieren, um die Tabelle als skalierbares Ziel zu registrieren und die bereitgestellte Schreib- oder Lesekapazität anzupassen.
Weitere Informationen zum Erstellen einer Tabelle mit mehreren Regionen und zum Konfigurieren verschiedener Auto Scaling-Einstellungen für Tabellenreplikate finden Sie unter. [Erstellen Sie eine Tabelle mit mehreren Regionen im Bereitstellungsmodus mit auto Skalierung in Amazon Keyspaces](tables-mrr-create-provisioned.md)
**Anmerkung**
Die automatische Skalierung von Amazon Keyspace erfordert das Vorhandensein einer serviceverknüpften Rolle (`AWSServiceRoleForApplicationAutoScaling_CassandraTable`), die automatische Skalierungsaktionen in Ihrem Namen ausführt. Diese Rolle wird automatisch für Sie erstellt. Weitere Informationen finden Sie unter [Verwenden von serviceverknüpften Rollen für Amazon Keyspaces](using-service-linked-roles.md).
------
#### [ Console ]
**Erstellen Sie mithilfe der Konsole eine neue Tabelle mit aktivierter automatischer Skalierung**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon Keyspaces-Konsole zu [https://console.aws.amazon.com/keyspaces/Hause](https://console.aws.amazon.com/keyspaces/home).
1. Wählen Sie im Navigationsbereich **Tables** (Tabellen) und anschließend **Create table** (Tabelle erstellen) aus.
1. Wählen Sie auf der Seite **Tabelle erstellen** im Abschnitt **Tabellendetails** einen Schlüsselraum aus und geben Sie einen Namen für die neue Tabelle ein.
1. Erstellen Sie im Abschnitt **Spalten** das Schema für Ihre Tabelle.
1. Definieren Sie im Abschnitt **Primärschlüssel** den Primärschlüssel der Tabelle und wählen Sie optionale Clusterspalten aus.
1. Wählen Sie im Abschnitt **Tabelleneinstellungen** die Option **Einstellungen anpassen** aus.
1. Fahren Sie mit den **Lese-/Schreibkapazitätseinstellungen** fort.
1. **Wählen Sie für den **Kapazitätsmodus** die Option Bereitgestellt aus.**
1. Vergewissern **Sie sich, dass im Abschnitt Lesekapazität** die Option **Automatisch skalieren** ausgewählt ist.
In diesem Schritt wählen Sie die minimalen und maximalen Lesekapazitätseinheiten für die Tabelle sowie die Zielauslastung aus.
+ **Mindestkapazitätseinheiten** — Geben Sie den Wert für den Mindestdurchsatz ein, den die Tabelle immer unterstützen soll. Der Wert muss zwischen 1 und dem maximalen Kontingent für den Durchsatz pro Sekunde für Ihr Konto liegen (standardmäßig 40.000).
+ **Einheiten mit maximaler Kapazität** — Geben Sie den maximalen Durchsatz ein, den Sie für die Tabelle bereitstellen möchten. Der Wert muss zwischen 1 und dem maximalen Kontingent für den Durchsatz pro Sekunde für Ihr Konto liegen (standardmäßig 40.000).
+ **Zielauslastung** — Geben Sie eine Zielauslastungsrate zwischen 20 und 90% ein. Wenn der Verkehr die definierte Zielauslastungsrate überschreitet, wird die Kapazität automatisch hochskaliert. Wenn der Verkehr unter das definierte Ziel fällt, wird er automatisch wieder herunterskaliert.
**Anmerkung**
Weitere Informationen zu Standardkontingenten für Ihr Konto und deren Erhöhung finden Sie unter[Kontingente für Amazon Keyspaces (für Apache Cassandra)](quotas.md).
1. Wählen **Sie im Abschnitt Schreibkapazität** dieselben Einstellungen wie im vorherigen Schritt für die Lesekapazität aus, oder konfigurieren Sie die Kapazitätswerte manuell.
1. Wählen Sie **Create table** (Tabelle erstellen) aus. Ihre Tabelle wird mit den angegebenen Parametern für die automatische Skalierung erstellt.
------
#### [ Cassandra Query Language (CQL) ]
**Erstellen Sie eine neue Tabelle mit der automatischen Skalierung von Amazon Keyspaces mithilfe von CQL**
Um Auto Scaling-Einstellungen für eine Tabelle programmgesteuert zu konfigurieren, verwenden Sie die `AUTOSCALING_SETTINGS` Anweisung, die die Parameter für Amazon Keyspaces Auto Scaling enthält. Die Parameter definieren die Bedingungen, unter denen Amazon Keyspaces angewiesen wird, den bereitgestellten Durchsatz Ihrer Tabelle anzupassen, und welche zusätzlichen optionalen Aktionen zu ergreifen sind. In diesem Beispiel definieren Sie die Auto Scaling-Einstellungen für *mytable*.
Die Richtlinie enthält die folgenden Elemente:
+ `AUTOSCALING_SETTINGS`— Gibt an, ob Amazon Keyspaces die Durchsatzkapazität in Ihrem Namen anpassen darf. Die folgenden Werte sind erforderlich:
+ `provisioned_write_capacity_autoscaling_update`:
+ `minimum_units`
+ `maximum_units`
+ `provisioned_read_capacity_autoscaling_update`:
+ `minimum_units`
+ `maximum_units`
+ `scaling_policy`— Amazon Keyspaces unterstützt die Richtlinie zur Zielverfolgung. Um die Ziel-Tracking-Richtlinie zu definieren, konfigurieren Sie die folgenden Parameter.
+ `target_value`— Die auto Skalierung von Amazon Keyspaces stellt sicher, dass das Verhältnis von verbrauchter Kapazität zu bereitgestellter Kapazität auf oder nahe diesem Wert bleibt. Sie definieren `target_value` als Prozentsatz.
+ `disableScaleIn`: (Optional) Ein Wert, der `boolean` angibt, ob für die Tabelle deaktiviert oder aktiviert `scale-in` ist. Dieser Parameter ist standardmäßig deaktiviert. Stellen Sie zum `scale-in` Einschalten den `boolean` Wert auf ein`FALSE`. Das bedeutet, dass die Kapazität für eine Tabelle in Ihrem Namen automatisch herunterskaliert wird.
+ `scale_out_cooldown`— Eine Scale-Out-Aktivität erhöht den bereitgestellten Durchsatz Ihrer Tabelle. Um eine Abklingzeit für Scale-Out-Aktivitäten hinzuzufügen, geben Sie einen Wert in Sekunden für an. `scale_out_cooldown` Wenn Sie keinen Wert angeben, ist der Standardwert 0. Weitere Informationen zu Target Tracking und Cooldown-Perioden finden Sie unter [Target Tracking Scaling Policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) im *Application Auto Scaling User Guide*.
+ `scale_in_cooldown`— Eine Scale-In-Aktivität verringert den bereitgestellten Durchsatz Ihrer Tabelle. Um eine Abklingzeit für Scale-In-Aktivitäten hinzuzufügen, geben Sie einen Wert in Sekunden für an. `scale_in_cooldown` Wenn Sie keinen Wert angeben, ist der Standardwert 0. Weitere Informationen zu Target Tracking und Cooldown-Perioden finden Sie unter [Target Tracking Scaling Policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) im *Application Auto Scaling User Guide*.
**Anmerkung**
Um besser zu verstehen, wie der `target_value` funktioniert, nehmen Sie an, dass Sie über eine Tabelle mit einer Einstellung des bereitgestellten Durchsatzes von 200 Schreibkapazitätseinheiten verfügen. Sie entscheiden sich dafür, eine Skalierungsrichtlinie für diese Tabelle mit einem `target_value` von 70 % zu erstellen.
Angenommen, Sie beginnen den Schreibverkehr zu der Tabelle zu leiten, damit der tatsächliche Schreibdurchsatz bei 150 Kapazitätseinheiten liegt. Das consumed-to-provisioned Verhältnis liegt jetzt bei (150/ 200) oder 75 Prozent. Dieses Verhältnis übersteigt Ihr Ziel, sodass Auto Scaling die bereitgestellte Schreibkapazität auf 215 erhöht, sodass das Verhältnis (150/ 215) oder 69,77 Prozent so nahe `target_value` wie möglich an Ihrem liegt, aber nicht überschritten wird.
Für *mytable* haben Sie sowohl die Lese- als auch `TargetValue` die Schreibkapazität auf 50 Prozent festgelegt. Amazon Keyspaces Auto Scaling passt den bereitgestellten Durchsatz der Tabelle im Bereich von 5 bis 10 Kapazitätseinheiten an, sodass das consumed-to-provisioned Verhältnis bei oder nahe 50 Prozent bleibt. Für die Lesekapazität legen Sie die Werte für `ScaleOutCooldown` und auf 60 Sekunden fest. `ScaleInCooldown`
Sie können die folgende Anweisung verwenden, um eine neue Amazon Keyspaces-Tabelle mit aktivierter auto Skalierung zu erstellen.
```
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 ]
**Erstellen Sie eine neue Tabelle mit der automatischen Skalierung von Amazon Keyspaces mithilfe der AWS CLI**
Um Auto Scaling-Einstellungen für eine Tabelle programmgesteuert zu konfigurieren, verwenden Sie die `autoScalingSpecification` Aktion, die die Parameter für Amazon Keyspaces Auto Scaling definiert. Die Parameter definieren die Bedingungen, unter denen Amazon Keyspaces angewiesen wird, den bereitgestellten Durchsatz Ihrer Tabelle anzupassen, und welche zusätzlichen optionalen Aktionen zu ergreifen sind. In diesem Beispiel definieren Sie die Auto Scaling-Einstellungen für *mytable*.
Die Richtlinie enthält die folgenden Elemente:
+ `autoScalingSpecification`— Gibt an, ob Amazon Keyspaces den Kapazitätsdurchsatz in Ihrem Namen anpassen darf. Sie können Auto Scaling für Lese- und Schreibkapazität separat aktivieren. Dann müssen Sie die folgenden Parameter angeben für`autoScalingSpecification`:
+ `writeCapacityAutoScaling`— Die Einheiten mit der maximalen und minimalen Schreibkapazität.
+ `readCapacityAutoScaling`— Die maximalen und minimalen Lesekapazitätseinheiten.
+ `scalingPolicy`— Amazon Keyspaces unterstützt die Richtlinie zur Zielverfolgung. Um die Ziel-Tracking-Richtlinie zu definieren, konfigurieren Sie die folgenden Parameter.
+ `targetValue`— Die auto Skalierung von Amazon Keyspaces stellt sicher, dass das Verhältnis von verbrauchter Kapazität zu bereitgestellter Kapazität auf oder nahe diesem Wert bleibt. Sie definieren `targetValue` als Prozentsatz.
+ `disableScaleIn`: (Optional) Ein Wert, der `boolean` angibt, ob für die Tabelle deaktiviert oder aktiviert `scale-in` ist. Dieser Parameter ist standardmäßig deaktiviert. Stellen Sie zum `scale-in` Einschalten den `boolean` Wert auf ein`FALSE`. Das bedeutet, dass die Kapazität für eine Tabelle in Ihrem Namen automatisch herunterskaliert wird.
+ `scaleOutCooldown`— Eine Scale-Out-Aktivität erhöht den bereitgestellten Durchsatz Ihrer Tabelle. Um eine Abklingzeit für Scale-Out-Aktivitäten hinzuzufügen, geben Sie einen Wert in Sekunden für an. `ScaleOutCooldown` Der Standardwert lautet 0. Weitere Informationen zu Target Tracking und Cooldown-Perioden finden Sie unter [Target Tracking Scaling Policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) im *Application Auto Scaling User Guide*.
+ `scaleInCooldown`— Eine Scale-In-Aktivität verringert den bereitgestellten Durchsatz Ihrer Tabelle. Um eine Abklingzeit für Scale-In-Aktivitäten hinzuzufügen, geben Sie einen Wert in Sekunden für an. `ScaleInCooldown` Der Standardwert lautet 0. Weitere Informationen zu Target Tracking und Cooldown-Perioden finden Sie unter [Target Tracking Scaling Policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) im *Application Auto Scaling User Guide*.
**Anmerkung**
Um besser zu verstehen, wie der `TargetValue` funktioniert, nehmen Sie an, dass Sie über eine Tabelle mit einer Einstellung des bereitgestellten Durchsatzes von 200 Schreibkapazitätseinheiten verfügen. Sie entscheiden sich dafür, eine Skalierungsrichtlinie für diese Tabelle mit einem `TargetValue` von 70 % zu erstellen.
Angenommen, Sie beginnen den Schreibverkehr zu der Tabelle zu leiten, damit der tatsächliche Schreibdurchsatz bei 150 Kapazitätseinheiten liegt. Das consumed-to-provisioned Verhältnis liegt jetzt bei (150/ 200) oder 75 Prozent. Dieses Verhältnis übersteigt Ihr Ziel, sodass Auto Scaling die bereitgestellte Schreibkapazität auf 215 erhöht, sodass das Verhältnis (150/ 215) oder 69,77 Prozent so nahe `TargetValue` wie möglich an Ihrem liegt, aber nicht überschritten wird.
Für *mytable* haben Sie sowohl die Lese- als auch `TargetValue` die Schreibkapazität auf 50 Prozent festgelegt. Amazon Keyspaces Auto Scaling passt den bereitgestellten Durchsatz der Tabelle im Bereich von 5 bis 10 Kapazitätseinheiten an, sodass das consumed-to-provisioned Verhältnis bei oder nahe 50 Prozent bleibt. Für die Lesekapazität legen Sie die Werte für `ScaleOutCooldown` und auf 60 Sekunden fest. `ScaleInCooldown`
Beim Erstellen von Tabellen mit komplexen Auto-Scaling-Einstellungen ist es hilfreich, die Auto-Scaling-Einstellungen aus einer JSON-Datei zu laden. Für das folgende Beispiel können Sie die JSON-Beispieldatei von [auto-scaling.zip](samples/auto-scaling.zip) herunterladen und extrahieren`auto-scaling.json`, wobei Sie sich den Pfad zur Datei notieren. In diesem Beispiel befindet sich die JSON-Datei im aktuellen Verzeichnis. Informationen zu verschiedenen Dateipfadoptionen finden Sie unter [So laden Sie Parameter aus einer Datei](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
```
------
# Konfigurieren Sie die automatische Skalierung für eine bestehende Tabelle
Sie können eine bestehende Amazon Keyspaces-Tabelle aktualisieren, um die auto Skalierung für die Schreib- oder Lesekapazität der Tabelle zu aktivieren. Wenn Sie eine Tabelle aktualisieren, die sich derzeit im On-Demand-Kapazitätsmodus befindet, müssen Sie zunächst den Kapazitätsmodus der Tabelle in den Modus Bereitgestellte Kapazität ändern.
Weitere Informationen zum Aktualisieren der Auto Scaling-Einstellungen für eine Tabelle mit mehreren Regionen finden Sie unter[Aktualisieren Sie die bereitgestellten Kapazitäten und Auto-Scaling-Einstellungen für eine Tabelle mit mehreren Regionen in Amazon Keyspaces](tables-mrr-autoscaling.md).
Die automatische Skalierung von Amazon Keyspace erfordert das Vorhandensein einer serviceverknüpften Rolle (`AWSServiceRoleForApplicationAutoScaling_CassandraTable`), die automatische Skalierungsaktionen in Ihrem Namen ausführt. Diese Rolle wird automatisch für Sie erstellt. Weitere Informationen finden Sie unter [Verwenden von serviceverknüpften Rollen für Amazon Keyspaces](using-service-linked-roles.md).
------
#### [ Console ]
**Automatische Skalierung von Amazon Keyspaces für eine bestehende Tabelle konfigurieren**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon Keyspaces-Konsole zu [https://console.aws.amazon.com/keyspaces/Hause](https://console.aws.amazon.com/keyspaces/home).
1. Wählen Sie die Tabelle aus, mit der Sie arbeiten möchten, und wechseln Sie zur Registerkarte **Kapazität**.
1. Wählen Sie im Abschnitt **Kapazitätseinstellungen** die Option **Bearbeiten** aus.
1. Stellen Sie unter **Kapazitätsmodus** sicher, dass für die Tabelle der Modus **Bereitgestellte** Kapazität verwendet wird.
1. Wählen Sie **Automatisch skalieren** aus und lesen Sie Schritt 6 unter[Erstellen Sie eine neue Tabelle mit automatischer Skalierung](autoscaling.createTable.md), um die Lese- und Schreibkapazität zu bearbeiten.
1. Wenn die Einstellungen für die automatische Skalierung definiert sind, wählen Sie **Speichern**.
------
#### [ Cassandra Query Language (CQL) ]
**Konfiguration einer vorhandenen Tabelle mit der automatischen Skalierung von Amazon Keyspaces mithilfe von CQL**
Sie können die `ALTER TABLE` Anweisung für eine bestehende Amazon Keyspaces-Tabelle verwenden, um Auto Scaling für die Schreib- oder Lesekapazität der Tabelle zu konfigurieren. Wenn Sie eine Tabelle aktualisieren, die sich derzeit im On-Demand-Kapazitätsmodus befindet, müssen Sie sie `capacity_mode` auf bereitgestellt setzen. Wenn sich Ihre Tabelle bereits im Modus für bereitgestellte Kapazität befindet, kann dieses Feld weggelassen werden.
Im folgenden Beispiel aktualisiert die Anweisung die *Tabelle mytable*, die sich im On-Demand-Kapazitätsmodus befindet. Die Anweisung ändert den Kapazitätsmodus der Tabelle in den Bereitstellungsmodus mit aktivierter auto Skalierung.
Die Schreibkapazität wird im Bereich von 5—10 Kapazitätseinheiten mit einem Zielwert von 50% konfiguriert. Die Lesekapazität wird ebenfalls im Bereich von 5—10 Kapazitätseinheiten mit einem Zielwert von 50% konfiguriert. Für die Lesekapazität legen Sie die Werte für `scale_out_cooldown` und `scale_in_cooldown` auf 60 Sekunden fest.
```
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 ]
**Konfigurieren Sie eine bestehende Tabelle mit der automatischen Skalierung von Amazon Keyspaces mithilfe der AWS CLI**
Für eine bestehende Amazon Keyspaces-Tabelle können Sie mithilfe des `UpdateTable` Vorgangs die auto Skalierung für die Schreib- oder Lesekapazität der Tabelle aktivieren.
Sie können den folgenden Befehl verwenden, um Amazon Keyspaces Auto Scaling für eine bestehende Tabelle zu aktivieren. Die Auto-Scaling-Einstellungen für die Tabelle werden aus einer JSON-Datei geladen. Für das folgende Beispiel können Sie die JSON-Beispieldatei von [auto-scaling.zip](samples/auto-scaling.zip) herunterladen und extrahieren`auto-scaling.json`, wobei Sie sich den Pfad zur Datei notieren. In diesem Beispiel befindet sich die JSON-Datei im aktuellen Verzeichnis. Informationen zu verschiedenen Dateipfadoptionen finden Sie unter [So laden Sie Parameter aus einer Datei](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html#cli-usage-parameters-file-how).
Weitere Informationen zu den im folgenden Beispiel verwendeten Auto Scaling-Einstellungen finden Sie unter[Erstellen Sie eine neue Tabelle mit automatischer Skalierung](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
```
------
# Sehen Sie sich die Amazon Keyspaces-Auto-Scaling-Konfiguration Ihrer Tabelle an
Sie können die Konsole, CQL oder die verwenden, AWS CLI um die automatischen Skalierungseinstellungen von Amazon Keyspaces einer Tabelle anzuzeigen und zu aktualisieren.
------
#### [ Console ]
****
**Die Einstellungen für die automatische Skalierung mithilfe der Konsole anzeigen**
1. Wählen Sie die Tabelle aus, die Sie anzeigen möchten, und wechseln Sie zur Registerkarte **Kapazität**.
1. Wählen Sie im Abschnitt **Kapazitätseinstellungen** die Option **Bearbeiten** aus. Sie können jetzt die Einstellungen in den Abschnitten **Lesekapazität** oder **Schreibkapazität** ändern. Weitere Informationen zu diesen Einstellungen finden Sie unter [Erstellen Sie eine neue Tabelle mit automatischer Skalierung](autoscaling.createTable.md).
------
#### [ Cassandra Query Language (CQL) ]
**Die automatische Skalierungsrichtlinie von Amazon Keyspaces für Ihre Tabelle mithilfe von CQL anzeigen**
Verwenden Sie den folgenden Befehl, um Details der Auto Scaling-Konfiguration einer Tabelle anzuzeigen.
```
SELECT * FROM system_schema_mcs.autoscaling WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
Die Ausgabe für diesen Befehl sieht wie folgt aus.
```
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 ]
**Sehen Sie sich die automatische Skalierungsrichtlinie von Amazon Keyspaces für Ihre Tabelle an, indem Sie AWS CLI**
Um die Auto Scaling-Konfiguration einer Tabelle anzuzeigen, können Sie den `get-table-auto-scaling-settings` Vorgang verwenden. Der folgende CLI-Befehl ist ein Beispiel dafür.
```
aws keyspaces get-table-auto-scaling-settings --keyspace-name mykeyspace --table-name mytable
```
Die Ausgabe für diesen Befehl sieht so aus.
```
{
"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
}
}
}
}
}
```
------
# auto Skalierung von Amazon Keyspaces für eine Tabelle ausschalten
Sie können die auto Skalierung von Amazon Keyspaces für Ihre Tabelle jederzeit deaktivieren. Wenn Sie die Lese- oder Schreibkapazität Ihrer Tabelle nicht mehr skalieren müssen, sollten Sie erwägen, Auto Scaling zu deaktivieren, damit Amazon Keyspaces die Lese- oder Schreibkapazitätseinstellungen Ihrer Tabelle nicht weiter ändert. Sie können die Tabelle mit der Konsole, CQL oder dem aktualisieren. AWS CLI
Wenn Sie Auto Scaling ausschalten, werden auch die CloudWatch Alarme gelöscht, die in Ihrem Namen erstellt wurden.
Um die serviceverknüpfte Rolle zu löschen, die von Application Auto Scaling für den Zugriff auf Ihre Amazon Keyspaces-Tabelle verwendet wird, folgen Sie den Schritten unter. [Löschen einer serviceverknüpften Rolle für Amazon Keyspaces](using-service-linked-roles-app-auto-scaling.md#delete-service-linked-role-app-auto-scaling)
**Anmerkung**
Um die dienstverknüpfte Rolle zu löschen, die Application Auto Scaling verwendet, müssen Sie die automatische Skalierung für alle Tabellen im Konto deaktivieren. AWS-Regionen
------
#### [ Console ]
**Schalten Sie die automatische Skalierung von Amazon Keyspace für Ihre Tabelle mithilfe der Konsole aus**
**Verwenden der Amazon Keyspaces-Konsole**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon Keyspaces-Konsole zu [https://console.aws.amazon.com/keyspaces/Hause](https://console.aws.amazon.com/keyspaces/home).
1. Wählen Sie die Tabelle aus, die Sie aktualisieren möchten, und wechseln Sie zur Registerkarte **Kapazität**.
1. Wählen Sie im Abschnitt **Kapazitätseinstellungen** die Option **Bearbeiten** aus.
1. Um die automatische Skalierung von Amazon Keyspaces zu deaktivieren, deaktivieren Sie das Kontrollkästchen **Automatisch skalieren**. Wenn Sie die automatische Skalierung deaktivieren, wird die Tabelle mit Application Auto Scaling als skalierbares Ziel abgemeldet.
------
#### [ Cassandra Query Language (CQL) ]
**Deaktivieren Sie die automatische Skalierung von Amazon Keyspace für Ihre Tabelle mithilfe von CQL**
Die folgende Anweisung deaktiviert die auto Skalierung für die Schreibkapazität der Tabelle *mytable*.
```
ALTER TABLE mykeyspace.mytable
WITH AUTOSCALING_SETTINGS = {
'provisioned_write_capacity_autoscaling_update': {
'autoscaling_disabled': true
}
};
```
------
#### [ CLI ]
**Deaktivieren Sie die automatische Skalierung von Amazon Keyspace für Ihre Tabelle mithilfe der AWS CLI**
Der folgende Befehl deaktiviert die auto Skalierung für die Lesekapazität der Tabelle. Außerdem werden die CloudWatch Alarme gelöscht, die in Ihrem Namen erstellt wurden.
```
aws keyspaces update-table --keyspace-name mykeyspace --table-name mytable
\ --auto-scaling-specification readCapacityAutoScaling={autoScalingDisabled=true}
```
------
# Auto-Scaling-Aktivitäten für eine Amazon Keyspaces-Tabelle in Amazon anzeigen CloudWatch
Sie können mithilfe von Amazon überwachen, wie die automatische Skalierung von Amazon Keyspaces Ressourcen verwendet. Amazon CloudWatch generiert Messwerte zu Ihrer Nutzung und Leistung. Folgen Sie den Schritten im [Application Auto Scaling Benutzerhandbuch](https://docs.aws.amazon.com/autoscaling/application/userguide/monitoring-cloudwatch.html), um ein CloudWatch Dashboard zu erstellen.
# Effektive Nutzung von Burst-Kapazitäten in Amazon Keyspaces
*Amazon Keyspaces bietet eine gewisse Flexibilität bei der Durchsatzbereitstellung pro Partition, indem es Burst-Kapazität bereitstellt.* Immer wenn Sie den Durchsatz einer Partition nicht vollständig nutzen, reserviert Amazon Keyspaces einen Teil dieser ungenutzten Kapazität für spätere *Durchsatzspitzen,* um Nutzungsspitzen zu bewältigen.
Amazon Keyspaces behält derzeit bis zu 5 Minuten (300 Sekunden) ungenutzte Lese- und Schreibkapazität. Bei gelegentlichen Lese- oder Schreibaktivitäten können diese zusätzlichen Kapazitätseinheiten schnell verbraucht werden — sogar schneller als die pro Sekunde bereitgestellte Durchsatzkapazität, die Sie für Ihre Tabelle definiert haben.
Amazon Keyspaces kann auch ohne vorherige Ankündigung Burst-Kapazität für die Hintergrundwartung und andere Aufgaben verbrauchen.
Beachten Sie, dass die Burst-Kapazität in Zukunft geändert werden kann.