Cara kerja penagihan di Aurora DSQL

Dengan Amazon Aurora DSQL, Anda hanya membayar untuk apa yang Anda gunakan tanpa biaya di muka. Bagian ini menjelaskan bagaimana Aurora DSQL mengukur aktivitas database Anda dan menerjemahkannya ke dalam tagihan Anda. AWS Untuk harga saat ini menurut Wilayah, lihat halaman harga Aurora DSQL.

Cara kerja metering

Tidak seperti database tradisional yang mengenakan biaya untuk kapasitas yang disediakan, Aurora DSQL mengenakan biaya hanya untuk pekerjaan aktual yang dilakukan. Aurora DSQL meter dua komponen utama: aktivitas database, diukur dalam Unit Pemrosesan Terdistribusi (DPUs), dan penyimpanan, diukur dalam bulan GIB.

DPUs mengukur berapa banyak pekerjaan yang dilakukan sistem untuk menjalankan beban kerja SQL Anda dan terdiri dari tiga komponen untuk kluster Single-region: DPUs Compute, Read, dan Write. DPUs DPUs Cluster Multi-Region mengeluarkan komponen MultiRegion Write DPU tambahan. Untuk detailnya, lihat Penagihan Multi-Wilayah.

Tabel berikut merangkum komponen yang Aurora DSQL gunakan untuk mengukur aktivitas database Anda. Pada tagihan Anda, Anda hanya melihat dua item baris: satu untuk penyimpanan dan satu untuk DPU, yang merupakan jumlah dari masing-masing komponen.

Pengukuran komponen DPU dijelaskan

Untuk setiap transaksi, Aurora DSQL menghitung total DPU sebagai jumlah dari tiga komponen: Compute DPU, Read DPU, dan Write DPU. Bagian berikut menjelaskan bagaimana Aurora DSQL meter setiap komponen.

Total DPU = ComputeDPU + ReadDPU + WriteDPU

ComputedPU

Komputasi DPUs diukur menggunakan total waktu pemrosesan yang dihabiskan untuk mengeksekusi kueri Anda, termasuk gabungan, fungsi, agregasi, pengurutan, dan perencanaan kueri. Karena bagian dari kueri Anda dapat diproses secara paralel, DPU Komputasi mencerminkan jumlah semua waktu pemrosesan — bukan waktu jam dinding kueri.

Rumus berikut merangkum cara menghitung Compute DPUs:

ComputeDPU = Total Compute time (in seconds)

DitulisPU

Untuk setiap transaksi, Aurora DSQL mengukur Write DPUs dengan total byte yang ditulis ke penyimpanan. Tulis DPUs sertakan total data yang ditulis ke tabel dasar Anda serta indeks sekunder apa pun. Aurora DSQL menagih setiap baris yang ditulis ke tabel dasar Anda dan indeks sekunder yang lebih kecil dari 128 byte seolah-olah itu adalah 128 byte. Aurora DSQL menagih transaksi tulis yang menulis kurang dari 1.024 byte seolah-olah menulis 1.024 byte.

Rumus berikut menunjukkan langkah-langkah untuk menghitung Tulis DPUs:

Langkah 1: Hitung byte tertulis

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

Langkah 2: Hitung WritedPU

WriteDPU = max(Bytes Written, 1024) × 0.00004883

bacaDPU

Untuk setiap transaksi, Aurora DSQL mengukur Read DPUs by total byte yang dibaca dari penyimpanan. Baca DPUs termasuk data yang dibaca dari tabel dasar Anda serta indeks sekunder apa pun.

Minimum per partisi: Aurora DSQL mengukur byte baca per partisi penyimpanan, bukan per baris. Jika permintaan baca ke partisi penyimpanan mengembalikan kurang dari 128 byte, Aurora DSQL membulatkannya hingga 128 byte. Misalnya, jika kueri Anda membaca dari 4 partisi — 200 byte dari satu partisi dan 50 byte dari masing-masing tiga partisi lainnya — tiga pembacaan 50 byte masing-masing dibulatkan menjadi 128 byte, menghasilkan total 200 + 128 + 128 + 128 = 584 byte yang ditagih.

Minimum transaksi: Aurora DSQL menagih transaksi baca yang berbunyi kurang dari 2.048 byte secara total seolah-olah membaca 2.048 byte.

Rumus berikut menunjukkan langkah-langkah untuk menghitung Baca DPUs:

Langkah 1: Hitung byte yang dibaca

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

Langkah 2: Hitung ReadDPU

ReadDPU = max(Bytes Read, 2048) × 0.00000183105

Contoh penagihan

Contoh berikut menunjukkan bagaimana Aurora DSQL menghitung DPUs untuk operasi umum. Nilai biaya dalam contoh ini menggunakan harga Wilayah us-east-1. Untuk harga di Wilayah lain, lihat halaman harga Aurora DSQL.

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

Penagihan Multi-Region

Cluster Multi-Region mengeluarkan komponen MultiRegion Write DPU tambahan di atas Compute, Read, dan Write standar. DPUs Bagian ini hanya berlaku untuk klaster Multi-wilayah. Cluster Single-Region tidak dikenakan biaya ini.

MultiRegion Tulis DPUs ukur total byte yang ditulis ke Wilayah yang diintip. Karena Aurora DSQL secara sinkron mereplikasi data yang Anda tulis ke Wilayah peered, nilai Write DPU setara dengan MultiRegion Write DPU. Aurora DSQL membebankan DPU ini di Wilayah tempat penulisan berasal, bukan di Wilayah yang diintip.

MultiRegionWriteDPU = WriteDPU

Memantau penggunaan DPU dengan CloudWatch

Aurora DSQL menerbitkan metrik penggunaan ke Amazon CloudWatch, memungkinkan Anda memantau konsumsi dalam waktu dekat.

Metrik DPU yang tersedia

Melihat metrik DPU

Metrik observabilitas tambahan

Untuk daftar lengkap metrik Aurora DSQL dan kemampuan pemantauan, lihat. Pemantauan dan pencatatan untuk Aurora DSQL

Menggunakan EXPLORE ANALYZE VERBOSE untuk kesadaran biaya

Aurora DSQL diperluas EXPLAIN ANALYZE VERBOSE untuk menyertakan perkiraan penggunaan DPU tingkat pernyataan pada akhir output. Ini memberikan visibilitas langsung ke biaya kueri, membantu Anda mengidentifikasi driver biaya beban kerja, menyesuaikan kinerja kueri, dan perkiraan penggunaan sumber daya yang lebih baik.

Contoh 1: SELECT query

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

Dalam contoh ini, pernyataan SELECT melakukan pemindaian indeks saja, sehingga sebagian besar biaya berasal dari Baca DPU (0,04312), mewakili data yang diambil dari penyimpanan dan Compute DPU (0,01607), yang mencerminkan sumber daya komputasi yang digunakan untuk memproses dan mengembalikan hasilnya. Tidak ada Write DPU karena kueri tidak mengubah data. Total DPU (0,05919) adalah jumlah dari Compute + Read+Write.

Contoh 2: Insert query

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

Pernyataan ini terutama melakukan penulisan, sehingga sebagian besar biaya dikaitkan dengan Tulis DPU. Compute DPU (0,01550) mewakili pekerjaan yang dilakukan untuk memproses dan menyisipkan nilai. DPU Baca (0,00307) mencerminkan pembacaan sistem minor (untuk pencarian katalog atau pemeriksaan indeks).

Perhatikan minimum transaksi yang ditunjukkan dalam tanda kurung di sebelah Baca dan Tulis. DPUs Minimum ini berlaku pada tingkat transaksi, artinya total DPU Baca atau Tulis untuk seluruh transaksi tidak pernah kurang dari nilai-nilai ini. Jika Anda menggunakan EXPLAIN ANALYZE VERBOSE untuk memperkirakan biaya dan ini adalah satu-satunya pernyataan dalam transaksi, gunakan nilai minimum transaksi daripada perkiraan pernyataan mentah. Jika transaksi berisi beberapa pernyataan, minimum berlaku untuk agregat di semua pernyataan. Karena EXPLAIN ANALYZE VERBOSE melaporkan perkiraan tingkat pernyataan saat penagihan berlaku minimum tingkat transaksi, nilainya mungkin tidak sama persis dengan metrik atau data penagihan. CloudWatch

Menggunakan informasi DPU untuk optimasi

Perkiraan DPU per pernyataan memberi Anda cara yang ampuh untuk mengoptimalkan kueri di luar waktu eksekusi. Kasus penggunaan umum meliputi:

Menafsirkan informasi DPU

Ingatlah praktik terbaik berikut saat menggunakan data DPU dariEXPLAIN ANALYZE VERBOSE:

Praktik terbaik estimasi biaya