Comment fonctionne la facturation dans Aurora DSQL

Avec Amazon Aurora DSQL, vous ne payez que pour ce que vous utilisez, sans frais initiaux. Cette section explique comment Aurora DSQL mesure l'activité de votre base de données et la traduit en frais sur votre AWS facture. Pour connaître les tarifs actuels par région, consultez la page de tarification d'Aurora DSQL.

Comment fonctionne le comptage

Contrairement aux bases de données traditionnelles qui facturent la capacité allouée, Aurora DSQL facture uniquement le travail réellement effectué. Aurora DSQL mesure deux composants principaux : l'activité de la base de données, mesurée en unités de traitement distribuées (DPUs), et le stockage, mesuré en Go par mois.

DPUs mesurent la quantité de travail que le système effectue pour exécuter votre charge de travail SQL et sont composés de trois composants pour les clusters à région unique : calcul DPUs DPUs, lecture et écriture DPUs. Les clusters multirégionaux nécessitent un composant MultiRegion Write DPU supplémentaire. Pour plus de détails, consultez la section Facturation multirégionale.

Le tableau suivant récapitule les composants qu'Aurora DSQL utilise pour mesurer l'activité de votre base de données. Sur votre facture, vous ne voyez que deux rubriques : une pour le stockage et une pour le DPU, qui représente la somme de chacun des composants individuels.

Explication du dosage des composants DPU

Pour chaque transaction, Aurora DSQL calcule le DPU total comme la somme de trois composants : DPU de calcul, DPU de lecture et DPU d'écriture. Les sections suivantes expliquent comment Aurora DSQL mesure chaque composant.

Total DPU = ComputeDPU + ReadDPU + WriteDPU

PU informatique

DPUs Les calculs sont mesurés en utilisant le temps de traitement total passé à exécuter votre requête, y compris les jointures, les fonctions, les agrégations, le tri et la planification des requêtes. Certaines parties de votre requête pouvant être traitées en parallèle, le Compute DPU reflète la somme de tous les temps de traitement, et non l'heure de l'horloge murale de la requête.

La formule suivante résume le mode de calcul de Compute DPUs :

ComputeDPU = Total Compute time (in seconds)

PU écrit

Pour chaque transaction, Aurora DSQL mesure Write DPUs par le nombre total d'octets écrits sur le stockage. L'écriture DPUs inclut le total des données écrites dans votre table de base ainsi que tous les index secondaires. Aurora DSQL facture chaque ligne écrite dans votre table de base et dans vos index secondaires dont la valeur est inférieure à 128 octets comme si elle était de 128 octets. Aurora DSQL facture une transaction d'écriture qui écrit moins de 1 024 octets comme si elle écrivait 1 024 octets.

Les formules suivantes indiquent les étapes à suivre pour calculer Write DPUs :

Étape 1 : Calculez les octets écrits

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

Étape 2 : Calculez le WriteDPU

WriteDPU = max(Bytes Written, 1024) × 0.00004883

Lire le DPU

Pour chaque transaction, Aurora DSQL mesure le nombre total DPUs d'octets lus depuis le stockage. La lecture DPUs inclut les données lues à partir de votre table de base ainsi que de tout index secondaire.

Minimum par partition : Aurora DSQL mesure les octets lus par partition de stockage, et non par ligne. Si une demande de lecture envoyée à une partition de stockage renvoie moins de 128 octets, Aurora DSQL l'arrondit à 128 octets. Par exemple, si votre requête lit à partir de 4 partitions (200 octets d'une partition et 50 octets de chacune des trois autres), les trois lectures de 50 octets sont arrondies chacune à 128 octets, soit un total de 200 + 128 + 128 + 128 = 584 octets facturés.

Transaction minimale : Aurora DSQL facture une transaction de lecture qui lit moins de 2 048 octets au total comme si elle lisait 2 048 octets.

Les formules suivantes indiquent les étapes de calcul de Read DPUs :

Étape 1 : Calculez les octets lus

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

Étape 2 : Calculez ReadDPU

ReadDPU = max(Bytes Read, 2048) × 0.00000183105

Exemples de facturation

Les exemples suivants montrent comment Aurora DSQL calcule DPUs pour les opérations courantes. Dans ces exemples, les valeurs de coût utilisent le prix de la région us-east-1. Pour connaître les tarifs dans d'autres régions, consultez la page de tarification d'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

Facturation multirégionale

Les clusters multirégionaux nécessitent un composant MultiRegion Write DPU supplémentaire en plus des composants standard Compute, Read, and Write. DPUs Cette section s'applique uniquement aux clusters multirégionaux. Les clusters à région unique ne sont pas soumis à ces frais.

MultiRegion L'écriture DPUs mesure le nombre total d'octets écrits dans la région pair. Étant donné qu'Aurora DSQL réplique de manière synchrone les données que vous écrivez dans la région homologue, la valeur du DPU d' MultiRegion écriture est équivalente à celle du DPU d'écriture. Aurora DSQL charge ce DPU dans la région d'où provient l'écriture, et non dans la région homologue.

MultiRegionWriteDPU = WriteDPU

Surveillance de l'utilisation du DPU avec CloudWatch

Aurora DSQL publie des métriques d'utilisation sur Amazon CloudWatch, ce qui vous permet de surveiller la consommation en temps quasi réel.

Métriques du DPU disponibles

Affichage des métriques du DPU

Mesures d'observabilité supplémentaires

Pour obtenir la liste complète des métriques et des fonctionnalités de surveillance d'Aurora DSQL, consultezSurveillance et journalisation pour Aurora DSQL.

Utiliser EXPLAIN ANALYZE VERBOSE pour connaître les coûts

Aurora DSQL s'étend EXPLAIN ANALYZE VERBOSE pour inclure une estimation de l'utilisation du DPU au niveau des instructions à la fin de la sortie. Cela fournit une visibilité immédiate sur le coût des requêtes, vous aidant à identifier les facteurs de coût de la charge de travail, à optimiser les performances des requêtes et à mieux prévoir l'utilisation des ressources.

Exemple 1 : requête SELECT

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

Dans cet exemple, l'instruction SELECT effectue une analyse d'index uniquement. La majeure partie du coût provient donc de Read DPU (0,04312), qui représente les données extraites du stockage, et de Compute DPU (0,01607), qui reflète les ressources de calcul utilisées pour traiter et renvoyer les résultats. Il n'existe aucun DPU d'écriture puisque la requête ne modifie pas les données. Le DPU total (0,05919) est la somme de Compute + Read + Write.

Exemple 2 : requête INSERT

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

Cette instruction effectue principalement des écritures, de sorte que la majeure partie du coût est associée au DPU d'écriture. Le Compute DPU (0,01550) représente le travail effectué pour traiter et insérer les valeurs. Le DPU de lecture (0,00307) reflète les lectures mineures du système (pour les recherches de catalogue ou les vérifications d'index).

Notez les minimums de transaction indiqués entre parenthèses à côté de Read and Write. DPUs Ces minimums s'appliquent au niveau de la transaction, ce qui signifie que le total du DPU en lecture ou en écriture pour l'ensemble d'une transaction n'est jamais inférieur à ces valeurs. Si vous utilisez EXPLAIN ANALYZE VERBOSE pour prévoir les coûts et qu'il s'agit du seul relevé de la transaction, utilisez les valeurs minimales de la transaction plutôt que les estimations brutes du relevé. Si la transaction contient plusieurs relevés, les minimums s'appliquent à l'ensemble des relevés. Étant donné que EXPLAIN ANALYZE VERBOSE les estimations sont fournies au niveau des relevés alors que la facturation applique des minimums au niveau des transactions, les valeurs peuvent ne pas correspondre exactement aux mesures ou aux données de facturation. CloudWatch

Utilisation des informations du DPU pour l'optimisation

Les estimations du DPU par instruction vous offrent un moyen puissant d'optimiser les requêtes au-delà du simple temps d'exécution. Cas d’utilisation courants :

Interprétation des informations du DPU

Tenez compte des meilleures pratiques suivantes lorsque vous utilisez des données DPU provenant de EXPLAIN ANALYZE VERBOSE :

Bonnes pratiques en matière d'estimation des coûts