Como funciona o faturamento no Aurora DSQL

Com o Amazon Aurora DSQL, você paga apenas pelo que utiliza, sem custos iniciais. Esta seção explica como o Aurora DSQL mede a atividade do seu banco de dados e a converte em cobranças na sua fatura da AWS. Para os preços atuais por região, consulte a página Preço do Aurora DSQL.

Como funciona a medição

Diferentemente dos bancos de dados tradicionais, que cobram pela capacidade provisionada, o Aurora DSQL cobra apenas pelo trabalho efetivamente realizado. O Aurora DSQL mede dois componentes principais: a atividade do banco de dados, medida em Unidades de Processamento Distribuído (DPUs), e o armazenamento, medido em GiB-mês.

As DPUs medem quanto trabalho o sistema realiza para executar sua workload SQL e são compostas por três elementos para clusters de região única: DPUs de computação, DPUs de leitura e DPUs de gravação. Os clusters multirregionais incluem um componente adicional de DPU de gravação multirregional. Consulte detalhes em Faturamento multirregional.

A tabela a seguir resume os componentes que o Aurora DSQL utiliza para medir a atividade do banco de dados. Na sua fatura, você verá apenas dois itens: um para armazenamento e outro para DPU, que corresponde à soma de todos os componentes individuais.

Explicação da medição dos componentes de DPU

Para cada transação, o Aurora DSQL calcula o total de DPU como a soma de três componentes: DPU de computação, DPU de leitura e DPU de gravação. As seções a seguir explicam como o Aurora DSQL mede cada componente.

Total DPU = ComputeDPU + ReadDPU + WriteDPU

ComputeDPU

As DPUs de computação são medidas com base no tempo total de processamento gasto na execução da sua consulta, incluindo junções, funções, agregações, ordenação e planejamento da consulta. Como partes da sua consulta podem ser processadas em paralelo, a DPU de computação reflete a soma de todo o tempo de processamento, e não o tempo de relógio da execução da consulta.

A fórmula a seguir resume como calcular as DPUs de computação:

ComputeDPU = Total Compute time (in seconds)

WriteDPU

Para cada transação, o Aurora DSQL mede as DPUs de gravação pelo total de bytes gravados no armazenamento. As DPUs de gravação incluem o total de dados gravados na tabela base, bem como em quaisquer índices secundários. O Aurora DSQL fatura cada linha gravada na tabela base e nos índices secundários com menos de 128 bytes como se tivesse 128 bytes. O Aurora DSQL fatura uma transação de gravação que grava menos de 1.024 bytes como se tivesse gravado 1.024 bytes.

As fórmulas a seguir mostram as etapas para calcular as DPUs de gravação:

Etapa 1: calcular bytes gravados

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

Etapa 2: calcular WriteDPU

WriteDPU = max(Bytes Written, 1024) × 0.00004883

ReadDPU

Para cada transação, o Aurora DSQL mede as DPUs de leitura pelo total de bytes lidos do armazenamento. As DPUs de leitura incluem dados lidos da tabela base, bem como de quaisquer índices secundários.

Mínimo por partição: o Aurora DSQL mede bytes lidos por partição de armazenamento, não por linha. Se uma solicitação de leitura para uma partição de armazenamento retornar menos de 128 bytes, o Aurora DSQL arredondará para 128 bytes. Por exemplo, se a consulta lê de 4 partições: 200 bytes de uma partição e 50 bytes de cada uma das outras três, as três leituras de 50 bytes são arredondadas para 128 bytes cada, resultando em um total faturado de 200 + 128 + 128 + 128 = 584 bytes.

Mínimo por transação: o Aurora DSQL fatura uma transação de leitura que lê menos de 2.048 bytes no total como se tivesse lido 2.048 bytes.

As fórmulas a seguir mostram as etapas para calcular as DPUs de leitura:

Etapa 1: calcular bytes lidos

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

Etapa 2: calcular ReadDPU

ReadDPU = max(Bytes Read, 2048) × 0.00000183105

Exemplos de faturamento

Os exemplos a seguir demonstram como o Aurora DSQL calcula DPUs para operações comuns. Os valores de custo nesses exemplos utilizam o preço da região us-east-1. Consulte preços em outras regiões na página Preço do 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

Faturamento multirregional

Os clusters multirregionais geram um componente adicional de DPU de gravação multirregional, além das DPUs padrão de computação, leitura e gravação. Esta seção se aplica apenas a clusters multirregionais. Clusters de região única não geram essa cobrança.

As DPUs de gravação multirregional medem o total de bytes gravados na região emparelhada. Como o Aurora DSQL replica de forma síncrona os dados gravados na região emparelhada, o valor da DPU de gravação multirregional é equivalente ao da DPU de gravação. O Aurora DSQL cobra essa DPU na região de origem da gravação, não na região emparelhada.

MultiRegionWriteDPU = WriteDPU

Monitoramento do uso de DPU com o CloudWatch

O Aurora DSQL publica métricas de uso no Amazon CloudWatch, permitindo monitorar o consumo quase em tempo real.

Métricas de DPU disponíveis

Visualização de métricas de DPU

Métricas adicionais de observabilidade

Consulte uma lista completa dos recursos de monitoramento e métricas do Aurora DSQL em Monitoramento e registro em log do Aurora DSQL.

Uso de EXPLAIN ANALYZE VERBOSE para conscientização sobre custos

O Aurora DSQL estende EXPLAIN ANALYZE VERBOSE para incluir uma estimativa de uso de DPU por instrução ao final da saída. Isso oferece visibilidade imediata do custo da consulta, ajudando você a identificar os fatores de custo da workload, ajustar a performance da consulta e prever melhor o uso dos recursos.

Exemplo 1: consulta 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

Neste exemplo, a instrução SELECT executa uma verificação somente de índice, então a maior parte do custo vem da DPU de leitura (0,04312), representando os dados recuperados do armazenamento e da DPU de computação (0,01607), o que reflete os recursos computacionais utilizados para processar e exibir os resultados. Não há DPU de gravação, pois a consulta não modifica dados. A DPU total (0,05919) é a soma de computação + leitura + gravação.

Exemplo 2: consulta 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

Essa instrução executa principalmente gravações, portanto, a maior parte do custo está associada à DPU de gravação. A DPU de computação (0,01550) representa o trabalho realizado para processar e inserir os valores. A DPU de leitura (0,00307) reflete leituras secundárias do sistema (para pesquisas de catálogos ou verificações de índice).

Observe os mínimos por transação exibidos entre parênteses ao lado das DPUs de leitura e gravação. Esses mínimos se aplicam no nível da transação, ou seja, o total de DPU de leitura ou de gravação de uma transação inteira nunca é inferior a esses valores. Se estiver usando EXPLAIN ANALYZE VERBOSE para prever custos e esta for a única instrução na transação, utilize os valores mínimos por transação em vez das estimativas brutas por instrução. Se a transação contiver várias instruções, os mínimos se aplicam ao total agregado de todas as instruções. Como EXPLAIN ANALYZE VERBOSE fornece estimativas no nível da instrução, enquanto o faturamento aplica mínimos no nível da transação, os valores podem não corresponder exatamente às métricas do CloudWatch ou aos dados de faturamento.

Uso das informações de DPU para otimização

As estimativas de DPU por instrução oferecem uma maneira poderosa de otimizar as consultas além do tempo de execução. Entre os casos de uso comuns estão:

Interpretação das informações de DPU

Lembre-se das seguintes práticas recomendadas ao usar dados de DPU de EXPLAIN ANALYZE VERBOSE:

Práticas recomendadas para estimativa de custos