Scritture ottimizzate per la velocità effettiva

Questa pagina descrive come configurare il tempo di ritardo massimo di commit (scrittura) per ottimizzare la velocità effettiva di scrittura in Spanner.

Panoramica

Per garantire la coerenza dei dati, Spanner invia richieste di scrittura a tutte le repliche di voto nel database. Questo processo di replica può avere un overhead computazionale. Per ulteriori informazioni, consulta Replica.

Le scritture ottimizzate per la velocità effettiva consentono di ammortizzare questi costi di calcolo eseguendo contemporaneamente un gruppo di scritture. Per farlo, Spanner introduce un piccolo ritardo e raccoglie un gruppo di scritture che devono essere inviate agli stessi partecipanti alla votazione. L'esecuzione delle scritture in questo modo può fornire miglioramenti sostanziali della velocità effettiva a scapito di una latenza leggermente superiore.

Comportamento predefinito

Se non imposti un tempo di ritardo del commit, Spanner potrebbe impostare un piccolo ritardo se ritiene che questo ammortizzerà il costo delle scritture.

Casi d'uso comuni

Puoi impostare manualmente il ritardo delle richieste di scrittura in base alle esigenze della tua applicazione. Puoi anche disabilitare i ritardi di commit per le applicazioni altamente sensibili alla latenza impostando il tempo massimo di ritardo del commit su 0 ms.

Se disponi di un'applicazione con tolleranza di latenza e vuoi ottimizzare la velocità effettiva, impostare un ritardo di commit più lungo migliora significativamente la velocità effettiva, aumentando la latenza per ogni scrittura. Ad esempio, se stai eseguendo il caricamento in blocco di una grande quantità di dati e l'applicazione non è interessata alla velocità con cui Spanner scrive singoli dati, puoi impostare il ritardo di commit su un valore più lungo, ad esempio 100 ms. Ti consigliamo di iniziare con un valore di 100 ms e quindi di apportare modifiche in alto e in basso finché i compromessi di latenza e velocità effettiva non soddisfano le tue esigenze. Per la maggior parte delle applicazioni, un valore compreso tra 20 ms e 100 ms è più adatto.

Se hai un'applicazione sensibile alla latenza, anche quella di Spanner è sensibile alla latenza per impostazione predefinita. Se il carico di lavoro è Piccoli, Spanner potrebbe impostare un piccolo ritardo. Puoi provare a impostare un valore di 0 ms per determinare se la latenza ridotta a costo di una maggiore velocità effettiva è ragionevole per la tua applicazione.

Imposta tempi di ritardo per commit misti

Puoi configurare diversi tempi di ritardo massimi del commit sui sottoinsiemi delle tue scritture. Se lo fai, Spanner utilizza il tempo di ritardo più breve configurato per il set di scritture. Tuttavia, consigliamo di scegliere un singolo valore per la maggior parte dei casi d'uso, in quanto ciò si traduce in un comportamento più prevedibile.

Limitazioni

Puoi impostare un tempo di ritardo di commit compreso tra 0 e 500 ms. Se imposti ritardi di commit superiori a 500 ms, viene generato un errore.

Imposta ritardo massimo di commit nelle richieste di commit

Il parametro di ritardo massimo commit fa parte del metodo CommitRequest. Puoi accedere a questo metodo con l'API RPC, l'API REST o utilizzando la libreria client di 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

Monitora la latenza delle richieste di scrittura

Puoi monitorare l'utilizzo e la latenza della CPU di Spanner utilizzando la console Google Cloud. Quando imposti un tempo di ritardo più lungo per le richieste di scrittura, è previsto un possibile calo dell'utilizzo della CPU, mentre la latenza aumenta. Per saperne di più sulla latenza nelle richieste Spanner, consulta Acquisire e visualizzare la latenza delle richieste API Spanner.