So funktioniert die Abrechnung in Aurora DSQL

Mit Amazon Aurora DSQL zahlen Sie nur für das, was Sie tatsächlich nutzen, ohne Vorabkosten. In diesem Abschnitt wird erklärt, wie Aurora DSQL Ihre Datenbankaktivitäten misst und diese in Gebühren auf Ihrer AWS Rechnung umrechnet. Aktuelle Preise nach Regionen finden Sie auf der Aurora DSQL-Preisseite.

Wie funktioniert die Messung

Im Gegensatz zu herkömmlichen Datenbanken, die die bereitgestellte Kapazität in Rechnung stellen, berechnet Aurora DSQL nur die tatsächlich geleistete Arbeit. Aurora DSQL misst zwei Hauptkomponenten: Datenbankaktivität, gemessen in Distributed Processing Units (DPUs), und Speicher, gemessen in GiB-Monat.

DPUs messen, wie viel Arbeit das System für die Ausführung Ihrer SQL-Arbeitslast leistet. Bei Clustern mit nur einer Region bestehen sie aus drei Komponenten: Compute DPUs, Read DPUs und Write. DPUs Bei Clustern mit mehreren Regionen fällt eine zusätzliche MultiRegion Write-DPU-Komponente an. Einzelheiten finden Sie unter Abrechnung für mehrere Regionen.

In der folgenden Tabelle sind die Komponenten zusammengefasst, die Aurora DSQL zur Messung Ihrer Datenbankaktivität verwendet. Auf Ihrer Rechnung sehen Sie nur zwei Einzelposten: einen für Speicher und einen für DPU, also die Summe der einzelnen Komponenten.

Die Messung der DPU-Komponenten erklärt

Für jede Transaktion berechnet Aurora DSQL die gesamte DPU als Summe der drei Komponenten: DPU berechnen, DPU lesen und DPU schreiben. In den folgenden Abschnitten wird erklärt, wie Aurora DSQL die einzelnen Komponenten misst.

Total DPU = ComputeDPU + ReadDPU + WriteDPU

Berechnete CPU

Die Rechenleistung DPUs wird anhand der gesamten Verarbeitungszeit gemessen, die für die Ausführung Ihrer Abfrage aufgewendet wurde, einschließlich Verknüpfungen, Funktionen, Aggregationen, Sortierung und Abfrageplanung. Da Teile Ihrer Abfrage parallel verarbeitet werden können, spiegelt die Compute DPU die Summe der gesamten Verarbeitungszeit wider — nicht die Wanduhr der Abfrage.

Die folgende Formel fasst zusammen, wie Compute berechnet wird: DPUs

ComputeDPU = Total Compute time (in seconds)

CPU schreiben

Bei jeder Transaktion misst Aurora DSQL den Schreibvorgang DPUs anhand der Gesamtzahl der in den Speicher geschriebenen Byte. Write DPUs umfasst die Gesamtzahl der in Ihre Basistabelle geschriebenen Daten sowie alle sekundären Indizes. Aurora DSQL berechnet jede Zeile, die in Ihre Basistabelle geschrieben wird, und sekundäre Indizes, die kleiner als 128 Byte sind, als ob sie 128 Byte wären. Aurora DSQL berechnet eine Schreibtransaktion, die weniger als 1.024 Byte schreibt, als ob sie 1.024 Byte geschrieben hätte.

Die folgenden Formeln zeigen die Schritte zur Berechnung von Write: DPUs

Schritt 1: Berechnet die geschriebenen Bytes

Bytes Written = Sum of max(size of each row, 128 bytes) for all rows written

Schritt 2: Berechne die geschriebene CPU

WriteDPU = max(Bytes Written, 1024) × 0.00004883

DPU lesen

Für jede Transaktion misst Aurora DSQL Read DPUs anhand der Gesamtzahl der aus dem Speicher gelesenen Byte. Read DPUs schließt Daten ein, die aus Ihrer Basistabelle gelesen wurden, sowie alle Sekundärindizes.

Minimum pro Partition: Aurora DSQL misst gelesene Byte pro Speicherpartition, nicht pro Zeile. Wenn eine Leseanforderung an eine Speicherpartition weniger als 128 Byte zurückgibt, rundet Aurora DSQL sie auf 128 Byte auf. Wenn Ihre Abfrage beispielsweise aus 4 Partitionen liest — 200 Byte von einer Partition und 50 Byte von jeder der anderen drei —, werden die drei 50-Byte-Lesevorgänge jeweils auf 128 Byte aufgerundet, was zu einer Gesamtsumme von 200 + 128 + 128 + 128 = 584 Byte in Rechnung gestellt wird.

Mindesttransaktion: Aurora DSQL berechnet eine Lesetransaktion, die insgesamt weniger als 2.048 Byte liest, als ob sie 2.048 Byte gelesen hätte.

Die folgenden Formeln zeigen die Schritte zur Berechnung von Read: DPUs

Schritt 1: Berechne die gelesenen Byte

Bytes Read = # of rows read × size of each row

Schritt 2: ReadDPU berechnen

ReadDPU = max(Bytes Read, 2048) × 0.00000183105

Abrechnungsbeispiel

Die folgenden Beispiele zeigen, wie Aurora DSQL DPUs für allgemeine Operationen berechnet. Die Kostenwerte in diesen Beispielen verwenden den Preis für die Region us-east-1. Preise in anderen Regionen finden Sie auf der Aurora DSQL-Preisseite.

CREATE TABLE orders (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    customer_id VARCHAR(50) NOT NULL,
    order_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    total_amount DECIMAL(10,2),
    status VARCHAR(20)
);
-- Average row size: ~100 bytes

SELECT * FROM orders WHERE customer_id = 'cust-12345';

ReadDPU = max(500, 2048) × 0.00000183105 = 2048 × 0.00000183105 = 0.00375

ComputeDPU: 0.003
ReadDPU:    0.00375
WriteDPU:   0.0
-------------------
Total DPU:  0.00675

CREATE TABLE orders (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    customer_id VARCHAR(50) NOT NULL,
    order_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    total_amount DECIMAL(10,2),
    status VARCHAR(20)
);
-- Average row size: ~100 bytes
-- Table contains 100 orders for customer 'cust-12345'

SELECT * FROM orders 
WHERE customer_id = 'cust-12345' 
  AND total_amount > 500.00;

ReadDPU = max(10000, 2048) × 0.00000183105 = 10000 × 0.00000183105 = 0.01831

ComputeDPU: 0.008
ReadDPU:    0.01831
WriteDPU:   0.0
-------------------
Total DPU:  0.02631

CREATE TABLE orders (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    customer_id VARCHAR(50) NOT NULL,
    order_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    total_amount DECIMAL(10,2),
    status VARCHAR(20)
);
-- Average row size: ~100 bytes

INSERT INTO orders (customer_id, total_amount, status)
VALUES ('cust-67890', 150.00, 'pending');

1 row × max(100 bytes, 128 bytes) = 1 × 128 = 128 bytes

WriteDPU = max(128, 1024) × 0.00004883 = 1024 × 0.00004883 = 0.05

ReadDPU = 0.00375 (transaction minimum)

ComputeDPU: 0.008
ReadDPU:    0.00375
WriteDPU:   0.05
-------------------
Total DPU:  0.06175

CREATE TABLE orders (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    customer_id VARCHAR(50) NOT NULL,
    order_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    total_amount DECIMAL(10,2),
    status VARCHAR(20)
);
-- Average row size: ~100 bytes

INSERT INTO orders (customer_id, total_amount, status)
VALUES 
    ('cust-001', 100.00, 'pending'),
    ('cust-002', 150.00, 'pending'),
    ... -- 100 rows total
    ('cust-100', 200.00, 'pending');

100 rows × max(100 bytes, 128 bytes) = 100 × 128 = 12,800 bytes

WriteDPU = max(12800, 1024) × 0.00004883 = 12800 × 0.00004883 = 0.625

ReadDPU = max(1600, 2048) × 0.00000183105 = 2048 × 0.00000183105 = 0.00375

ComputeDPU: 0.08
ReadDPU:    0.00375
WriteDPU:   0.625
-------------------
Total DPU:  0.70875

Abrechnung über mehrere Regionen

Bei Clustern mit mehreren Regionen fällt zusätzlich zu den standardmäßigen Compute-, Read- und Write-Funktionen eine zusätzliche MultiRegion DPU-Schreibkomponente an. DPUs Dieser Abschnitt gilt nur für Cluster mit mehreren Regionen. Für Cluster mit einer Region fällt diese Gebühr nicht an.

MultiRegion Beim Schreiben wird die Gesamtzahl der Byte DPUs gemessen, die in die Peering-Region geschrieben wurden. Da Aurora DSQL die Daten, die Sie schreiben, synchron in die Peering-Region repliziert, entspricht der Write-DPU-Wert dem MultiRegion Write-DPU. Aurora DSQL berechnet diese DPU in der Region, aus der der Schreibvorgang stammt, und nicht in der Peering-Region.

MultiRegionWriteDPU = WriteDPU

Überwachung der DPU-Nutzung mit CloudWatch

Aurora DSQL veröffentlicht Nutzungsmetriken auf Amazon CloudWatch, sodass Sie den Verbrauch nahezu in Echtzeit überwachen können.

Verfügbare DPU-Metriken

DPU-Metriken anzeigen

Zusätzliche Messwerte zur Beobachtbarkeit

Eine vollständige Liste der Aurora DSQL-Metriken und Überwachungsfunktionen finden Sie unterÜberwachung und Protokollierung für Aurora DSQL.

Nutzen Sie EXPLAIN ANALYZE VERBOSE für ein besseres Kostenbewusstsein

Aurora DSQL wird erweitert EXPLAIN ANALYZE VERBOSE und enthält am Ende der Ausgabe eine Schätzung der DPU-Nutzung auf Anweisungsebene. Dies bietet einen sofortigen Einblick in die Abfragekosten und hilft Ihnen, Workload-Kostentreiber zu identifizieren, die Abfrageleistung zu optimieren und die Ressourcennutzung besser zu prognostizieren.

Beispiel 1: SELECT-Abfrage

EXPLAIN ANALYZE VERBOSE SELECT * FROM test_table;

QUERY PLAN
----------------------------------------------------
Index Only Scan using test_table_pkey on public.test_table  (cost=125100.05..171100.05 rows=1000000 width=36) (actual time=2.973..4.482 rows=120 loops=1)
  Output: id, context
  -> Storage Scan on test_table_pkey (cost=125100.05..171100.05 rows=1000000 width=36) (actual rows=120 loops=1)
      Projections: id, context
      -> B-Tree Scan on test_table_pkey (cost=125100.05..171100.05 rows=1000000 width=36) (actual rows=120 loops=1)
Query Identifier: qymgw1m77maoe
Planning Time: 11.415 ms
Execution Time: 4.528 ms
Statement DPU Estimate:
  Compute: 0.01607 DPU
  Read: 0.04312 DPU
  Write: 0.00000 DPU
  Total: 0.05919 DPU

In diesem Beispiel führt die SELECT-Anweisung einen reinen Index-Scan durch, sodass der Großteil der Kosten auf Read DPU (0,04312) entfällt, was die aus dem Speicher abgerufenen Daten darstellt, und Compute DPU (0,01607), was die Rechenressourcen widerspiegelt, die für die Verarbeitung und Rückgabe der Ergebnisse verwendet werden. Es gibt kein Write-DPU, da die Abfrage keine Daten ändert. Die gesamte DPU (0,05919) ist die Summe aus Compute+Read+Write.

Beispiel 2: INSERT-Abfrage

EXPLAIN ANALYZE VERBOSE INSERT INTO test_table VALUES (1, 'name1'), (2, 'name2'), (3, 'name3');

QUERY PLAN
----------------------------------------------------
Insert on public.test_table  (cost=0.00..0.04 rows=0 width=0) (actual time=0.055..0.056 rows=0 loops=1)
  ->  Values Scan on "*VALUES*"  (cost=0.00..0.04 rows=3 width=122) (actual time=0.003..0.008 rows=3 loops=1)
        Output: "*VALUES*".column1, "*VALUES*".column2
Query Identifier: jtkjkexhjotbo
Planning Time: 0.068 ms
Execution Time: 0.543 ms
Statement DPU Estimate:
  Compute: 0.01550 DPU
  Read: 0.00307 DPU (Transaction minimum: 0.00375)
  Write: 0.01875 DPU (Transaction minimum: 0.05000)
  Total: 0.03732 DPU

Diese Anweisung führt hauptsächlich Schreibvorgänge durch, sodass der Großteil der Kosten mit Write DPU verbunden ist. Die Rechen-DPU (0,01550) steht für die Arbeit, die für die Verarbeitung und das Einfügen der Werte aufgewendet wurde. Der Read DPU (0,00307) spiegelt kleinere Systemlesevorgänge wider (für Katalogsuchen oder Indexprüfungen).

Beachten Sie die Transaktions-Mindestwerte, die in Klammern neben Lesen und Schreiben angezeigt werden. DPUs Diese Mindestwerte gelten auf Transaktionsebene, was bedeutet, dass die gesamte DPU für Lese- oder Schreibvorgänge für eine gesamte Transaktion niemals unter diesen Werten liegt. Wenn Sie eine Kostenprognose verwenden EXPLAIN ANALYZE VERBOSE und dies die einzige Aussage in der Transaktion ist, verwenden Sie die Mindestwerte für die Transaktion und nicht die unformatierten Schätzungen für die Abrechnung. Wenn die Transaktion mehrere Kontoauszüge enthält, gelten die Mindestwerte für die Summe aller Kontoauszüge. Da Schätzungen auf EXPLAIN ANALYZE VERBOSE Kontoauszugsebene gemeldet werden, während für die Abrechnung Mindestwerte auf Transaktionsebene gelten, stimmen die Werte möglicherweise nicht exakt mit den Kennzahlen oder Abrechnungsdaten überein. CloudWatch

Verwendung von DPU-Informationen zur Optimierung

DPU-Schätzungen pro Anweisung bieten Ihnen eine leistungsstarke Möglichkeit, Abfragen über die reine Ausführungszeit hinaus zu optimieren. Häufige Anwendungsfälle umfassen:

DPU-Informationen interpretieren

Beachten Sie die folgenden bewährten Methoden bei der Verwendung von DPU-Daten von: EXPLAIN ANALYZE VERBOSE

Bewährte Methoden zur Kostenschätzung