Configura timeout transazione

Questa pagina descrive come impostare un timeout per le transazioni utilizzando le librerie client di Spanner. La transazione non va a buon fine con un errore DEADLINE_EXCEEDED se non può essere completata entro il valore di timeout specificato.

Se l'errore di timeout si verifica durante l'esecuzione della richiesta Commit, è comunque possibile che sia stato eseguito il commit della transazione.

Timeout RPC e loop di nuovi tentativi di transazione

I timeout RPC e i timeout delle transazioni limitano ambiti di lavoro diversi:

  • Un timeout RPC limita il tempo di esecuzione di una singola richiesta, ad esempio una query, una lettura o una richiesta Commit. Un timeout della transazione più lungo di un timeout RPC non estende il timeout RPC. Per saperne di più, consulta Configura timeout e tentativi personalizzati.
  • Un timeout della transazione limita il tempo totale impiegato dalla libreria client per eseguire una transazione di lettura/scrittura, incluso ogni tentativo effettuato dalla libreria client dopo che Spanner ha interrotto la transazione.

Quando Spanner interrompe una transazione di lettura/scrittura, la libreria client esegue nuovamente la funzione della transazione. I timeout RPC brevi non limitano il tempo per cui la libreria client continua a riprovare una transazione interrotta. Se non imposti un timeout della transazione, il comportamento di ripetizione predefinito dipende dalla libreria client:

  • Java: l'esecutore delle transazioni riprova le transazioni interrotte per un massimo di 24 ore, senza limiti al numero di tentativi.
  • Go: la libreria client riprova le transazioni interrotte fino a quando non viene eseguito il commit della transazione o fino a quando l'oggetto context.Context che passi alla transazione non raggiunge la scadenza o non viene annullato.
  • Node.js: la libreria client interrompe i nuovi tentativi di transazioni interrotte dopo 1 ora (3600000 millisecondi). Per modificare questo limite, imposta il campo timeout nell'oggetto RunTransactionOptions che passi al metodo runTransaction o runTransactionAsync.
  • Python: la libreria client interrompe i nuovi tentativi di transazioni interrotte dopo 30 secondi. Per modificare questo limite, passa l'argomento timeout_secs al metodo run_in_transaction.

Nei workload con un'elevata contesa dei blocchi, ogni tentativo di ripetizione compete per gli stessi blocchi, pertanto un ciclo di ripetizione lungo può aumentare i tempi di attesa dei blocchi per altre transazioni. Per limitare il tempo totale di esecuzione di una transazione, imposta un timeout della transazione come mostrato negli esempi in questa pagina.

Imposta un timeout della transazione

Puoi impostare un timeout della transazione utilizzando le librerie client Go, Java, Python e Node.js.

Vai


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

	"cloud.google.com/go/spanner"
	"google.golang.org/api/iterator"
	"google.golang.org/grpc/codes"
)

func transactionTimeout(w io.Writer, db string) error {
	ctx := context.Background()
	client, err := spanner.NewClient(ctx, db)
	if err != nil {
		return err
	}
	defer client.Close()

	// Create a context with a 60-second timeout and use this context to run a read/write transaction.
	// This context timeout will be applied to the entire transaction, and the transaction will fail
	// if it cannot finish within the specified timeout value. The Spanner client library applies the
	// (remainder of the) timeout to each statement that is executed in the transaction.
	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
	defer cancel()

	_, err = client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
		selectStmt := spanner.Statement{
			SQL: `SELECT SingerId, FirstName, LastName FROM Singers ORDER BY LastName, FirstName`,
		}
		// The context that is passed in to the transaction function should be used for each statement
		// is executed.
		iter := txn.Query(ctx, selectStmt)
		defer iter.Stop()
		for {
			row, err := iter.Next()
			if errors.Is(err, iterator.Done) {
				break
			}
			if err != nil {
				return err
			}
			var singerID int64
			var firstName, lastName string
			if err := row.Columns(&singerID, &firstName, &lastName); err != nil {
				return err
			}
			fmt.Fprintf(w, "%d %s %s\n", singerID, firstName, lastName)
		}
		stmt := spanner.Statement{
			SQL: `INSERT INTO Singers (SingerId, FirstName, LastName)
					VALUES (38, 'George', 'Washington')`,
		}
		rowCount, err := txn.Update(ctx, stmt)
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "%d record(s) inserted.\n", rowCount)
		return nil
	})
	// Check if an error was returned by the transaction.
	// The spanner.ErrCode(err) function will return codes.OK if err == nil.
	code := spanner.ErrCode(err)
	if code == codes.OK {
		fmt.Fprintf(w, "Transaction with timeout was executed successfully\n")
	} else if code == codes.DeadlineExceeded {
		fmt.Fprintf(w, "Transaction timed out\n")
	} else {
		fmt.Fprintf(w, "Transaction failed with error code %v\n", code)
	}
	return err
}

Java


import com.google.cloud.spanner.DatabaseClient;
import com.google.cloud.spanner.DatabaseId;
import com.google.cloud.spanner.ResultSet;
import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.Statement;
import io.grpc.Context;
import io.grpc.Context.CancellableContext;
import io.grpc.Deadline;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * Sample showing how to set a timeout for an entire transaction for the Cloud Spanner Java client.
 */
class TransactionTimeoutExample {

  static void executeTransactionWithTimeout() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";

    executeTransactionWithTimeout(projectId, instanceId, databaseId, 60L, TimeUnit.SECONDS);
  }

  // Execute a read/write transaction with a timeout for the entire transaction.
  static void executeTransactionWithTimeout(
      String projectId,
      String instanceId,
      String databaseId,
      long timeoutValue,
      TimeUnit timeoutUnit) {
    try (Spanner spanner = SpannerOptions.newBuilder().setProjectId(projectId).build()
        .getService()) {
      DatabaseClient client =
          spanner.getDatabaseClient(DatabaseId.of(projectId, instanceId, databaseId));
      // Create a gRPC context with a deadline and with cancellation.
      // gRPC context deadlines require the use of a scheduled executor.
      ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
      try (CancellableContext context =
          Context.current()
              .withDeadline(Deadline.after(timeoutValue, timeoutUnit), executor)
              .withCancellation()) {
        context.run(
            () -> {
              client
                  .readWriteTransaction()
                  .run(
                      transaction -> {
                        try (ResultSet resultSet =
                            transaction.executeQuery(
                                Statement.of(
                                    "SELECT SingerId, FirstName, LastName\n"
                                        + "FROM Singers\n"
                                        + "ORDER BY LastName, FirstName"))) {
                          while (resultSet.next()) {
                            System.out.printf(
                                "%d %s %s\n",
                                resultSet.getLong("SingerId"),
                                resultSet.getString("FirstName"),
                                resultSet.getString("LastName"));
                          }
                        }
                        String sql =
                            "INSERT INTO Singers (SingerId, FirstName, LastName)\n"
                                + "VALUES (20, 'George', 'Washington')";
                        long rowCount = transaction.executeUpdate(Statement.of(sql));
                        System.out.printf("%d record inserted.%n", rowCount);
                        return null;
                      });
            });
      }
    }
  }
}

Node.js

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

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

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

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

  const options = {
    timeout: 60000, // 60 seconds timeout
  };

  try {
    await database.runTransactionAsync(options, async tx => {
      const [results] = await tx.run(
        'SELECT SingerId, FirstName, LastName FROM Singers ORDER BY LastName, FirstName',
      );
      results.forEach(result => {
        console.log(
          `${result[0].name}: ${result[0].value.value}, ${result[1].name}: ${result[1].value}, ${result[2].name}: ${result[2].value}`,
        );
      });
      const sql =
        "INSERT INTO Singers (SingerId, FirstName, LastName) VALUES (100, 'George', 'Washington')";
      const [rowCount] = await tx.runUpdate(sql);
      console.log(`${rowCount} record inserted.`);
      await tx.commit();
    });
  } catch (err) {
    console.error('ERROR:', err);
  } finally {
    await database.close();
  }
}
executeTransactionWithTimeout();

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 read_then_write(transaction):
    # Read records.
    results = transaction.execute_sql(
        "SELECT SingerId, FirstName, LastName FROM Singers ORDER BY LastName, FirstName"
    )
    for result in results:
        print("SingerId: {}, FirstName: {}, LastName: {}".format(*result))

    # Insert a record.
    row_ct = transaction.execute_update(
        "INSERT INTO Singers (SingerId, FirstName, LastName) "
        " VALUES (100, 'George', 'Washington')"
    )
    print("{} record(s) inserted.".format(row_ct))

# configure transaction timeout to 60 seconds
database.run_in_transaction(read_then_write, timeout_secs=60)

Imposta un timeout per le transazioni Java asincrone

L'esempio Java in questa pagina utilizza un oggetto gRPC Context con una scadenza per impostare il timeout della transazione. L'oggetto gRPC Context è collegato al thread corrente.

Quando esegui una transazione in modo asincrono utilizzando il metodo AsyncRunner.runAsync(), la libreria client esegue la transazione sull'oggetto Executor che fornisci. La libreria client non propaga l'oggetto Context del thread chiamante, inclusa la scadenza, all'esecutore. Di conseguenza, la transazione viene eseguita senza timeout e può continuare a riprovare i tentativi interrotti per un massimo di 24 ore.

Per applicare il timeout a una transazione asincrona, esegui una delle seguenti operazioni:

  • Aggrega l'esecutore chiamando il metodo Context.currentContextExecutor(executor) mentre l'oggetto Context con la scadenza è corrente e passa l'esecutore aggregato al metodo runAsync().
  • Utilizza l'interfaccia AsyncTransactionManager o TransactionManager anziché l'interfaccia AsyncRunner. Con un gestore delle transazioni, scrivi tu il loop di nuovi tentativi e puoi interromperli alla scadenza del timeout.