Gravações otimizadas de throughput

Esta página descreve como configurar o tempo de confirmação (gravação) máximo para otimizar a taxa de transferência de gravação no Spanner.

Visão geral

Para garantir a consistência dos dados, o Spanner envia solicitações de gravação para todas as réplicas de votação no banco de dados. Esse processo de replicação pode ter sobrecarga computacional. Para mais informações, consulte Replicação.

As gravações otimizadas de throughput oferecem a opção de amortizar esses custos de computação executando um grupo de gravações. Para fazer isso, o Spanner introduz um pequeno atraso e coleta um grupo de gravações que precisam ser enviadas aos mesmos participantes da votação. A execução de gravações dessa forma pode proporcionar melhorias substanciais na capacidade de processamento ao custo de uma latente ligeiramente maior.

Comportamento padrão

Se você não definir um tempo de confirmação, o Spanner poderá definir um pequeno atraso se achar que isso vai amortizar o custo das suas gravações.

Casos de uso comuns

É possível definir manualmente o tempo de atraso das solicitações de gravação, dependendo das necessidades do aplicativo. Também é possível desativar os atrasos de confirmação para aplicativos altamente sensíveis à latência definindo o tempo máximo de atraso de confirmação como 0 ms.

Se você tiver um aplicativo tolerante à latência e quiser otimizar a capacidade de processamento, definir um tempo de confirmação mais longo melhora significativamente a capacidade de processamento, mas aumenta a latência para cada gravação. Por exemplo, se você estiver fazendo o carregamento em massa de uma grande quantidade de dados e o aplicativo não se importar com a rapidez com que o Spanner grava dados individuais, defina o tempo de confirmação para um valor mais longo, como 100 ms. Recomendamos que você comece com um valor de 100 ms e ajuste para cima e para baixo até que as compensações de latência e taxa de transferência satisfaçam suas necessidades. Para a maioria dos aplicativos, um valor entre 20 ms e 100 ms funciona melhor.

Se você tiver um aplicativo sensível à latência, o Spanner também será sensível à latência por padrão. Se você tiver uma carga de trabalho com picos, o Spanner poderá definir um pequeno atraso. Você pode experimentar a configuração de um valor de 0 ms para determinar se a latência reduzida com o custo do aumento de throughput é razoável para seu aplicativo.

Definir tempos de atraso de confirmação mistos

É possível configurar diferentes tempos de atraso de confirmação máxima em subconjuntos das suas gravações. Se você fizer isso, o Spanner vai usar o tempo de atraso mais curto configurado para o conjunto de gravações. No entanto, recomendamos escolher um único valor para a maioria dos casos de uso, porque isso resulta em um comportamento mais previsível.

Limitações

É possível definir um tempo de confirmação de 0 a 500 ms. A definição de confirmações com mais de 500 ms resulta em um erro.

Definir o atraso máximo de confirmação em solicitações de confirmação

O parâmetro de atraso máximo de confirmação faz parte do método CommitRequest. É possível acessar esse método com a API RPC, a API REST ou usando a biblioteca de cliente do Cloud Spanner.

Go

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/spanner"
)

// maxCommitDelay sets the maximum commit delay for a transaction.
func maxCommitDelay(w io.Writer, db string) error {
	// db = `projects/<project>/instances/<instance-id>/database/<database-id>`
	ctx := context.Background()
	client, err := spanner.NewClient(ctx, db)
	if err != nil {
		return fmt.Errorf("maxCommitDelay.NewClient: %w", err)
	}
	defer client.Close()

	// Set the maximum commit delay to 100ms.
	// This is the amount of latency this request is willing to incur in order
	// to improve throughput. If this field is not set, Spanner assumes requests
	// are relatively latency sensitive and automatically determines an
	// appropriate delay time. You can specify a batching delay value between 0 and 500 ms.
	// The transaction will also return the commit statistics.
	commitDelay := 100 * time.Millisecond
	resp, err := client.ReadWriteTransactionWithOptions(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
		stmt := spanner.Statement{
			SQL: `INSERT Singers (SingerId, FirstName, LastName)
					VALUES (111, 'Virginia', 'Watson')`,
		}
		rowCount, err := txn.Update(ctx, stmt)
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "%d record(s) inserted.\n", rowCount)
		return nil
	}, spanner.TransactionOptions{CommitOptions: spanner.CommitOptions{MaxCommitDelay: &commitDelay, ReturnCommitStats: true}})
	if err != nil {
		return fmt.Errorf("maxCommitDelay.ReadWriteTransactionWithOptions: %w", err)
	}
	fmt.Fprintf(w, "%d mutations in transaction\n", resp.CommitStats.MutationCount)
	return nil
}

Node.js

// Imports the Google Cloud client library.
const {Spanner, protos} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';

// Creates a client.
const spanner = new Spanner({
  projectId: projectId,
});

async function spannerSetMaxCommitDelay() {
  // Gets a reference to a Cloud Spanner instance and database.
  const instance = spanner.instance(instanceId);
  const database = instance.database(databaseId);

  database.runTransaction(async (err, transaction) => {
    if (err) {
      console.error(err);
      return;
    }
    try {
      const [rowCount] = await transaction.runUpdate({
        sql: 'INSERT Singers (SingerId, FirstName, LastName) VALUES (111, @firstName, @lastName)',
        params: {
          firstName: 'Virginia',
          lastName: 'Watson',
        },
      });

      console.log(
        `Successfully inserted ${rowCount} record into the Singers table.`
      );

      await transaction.commit({
        // The maximum amount of time to delay the transaction to improve
        // throughput.
        maxCommitDelay: protos.google.protobuf.Duration({
          seconds: 0, // 0 seconds
          nanos: 100000000, // 100,000,000 nanoseconds = 100 milliseconds
        }),
      });
    } catch (err) {
      console.error('ERROR:', err);
    } finally {
      // Close the database when finished.
      database.close();
    }
  });
}
spannerSetMaxCommitDelay();

Python

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

def insert_singers(transaction):
    row_ct = transaction.execute_update(
        "INSERT Singers (SingerId, FirstName, LastName) "
        " VALUES (111, 'Grace', 'Bennis')"
    )

    print("{} record(s) inserted.".format(row_ct))

database.run_in_transaction(
    insert_singers, max_commit_delay=datetime.timedelta(milliseconds=100)
)

Ruby

require "google/cloud/spanner"

##
# This is a snippet for showcasing how to pass max_commit_delay in  commit_options.
#
# @param project_id  [String] The ID of the Google Cloud project.
# @param instance_id [String] The ID of the spanner instance.
# @param database_id [String] The ID of the database.
#
def spanner_set_max_commit_delay project_id:, instance_id:, database_id:
  # Instantiates a client
  spanner = Google::Cloud::Spanner.new project: project_id
  client  = spanner.client instance_id, database_id

  records = [
    { SingerId: 1, AlbumId: 1, MarketingBudget: 200_000 },
    { SingerId: 2, AlbumId: 2, MarketingBudget: 400_000 }
  ]
  # max_commit_delay is the amount of latency in millisecond, this request
  # is willing to incur in order to improve throughput.
  # The commit delay must be at least 0ms and at most 500ms.
  # Default value is nil.
  commit_options = {
    return_commit_stats: true,
    max_commit_delay: 100
  }
  resp = client.upsert "Albums", records, commit_options: commit_options
  puts "Updated data with #{resp.stats.mutation_count} mutations."
end

Monitorar a latência da solicitação de gravação

É possível monitorar a utilização da CPU e a latência do Spanner usando o console doGoogle Cloud . Quando você define um tempo de atraso maior para as solicitações de gravação, a utilização da CPU pode diminuir, enquanto a latência aumenta. Para saber mais sobre a latência nas solicitações do Spanner, consulte Capturar e visualizar a latência da solicitação da API Spanner.