Regiegeführte Lektüre

Vorschau — Directed reads

Diese Funktion unterliegt den „Nutzungsbedingungen für Pre-GA-Angebote“ im Abschnitt „Allgemeine Nutzungsbedingungen“ der dienstspezifischen Nutzungsbedingungen. Pre-GA-Funktionen sind „wie besehen“ verfügbar und werden möglicherweise nur eingeschränkt unterstützt. Weitere Informationen finden Sie in den Beschreibungen der Startphase.

Auf dieser Seite werden gerichtete Spanner-Lesevorgänge und ihre Verwendung beschrieben.

Gerichtete Lesevorgänge in Spanner bieten die Flexibilität, schreibgeschützte Transaktionen und einzelne Lesevorgänge an einen bestimmten Replikattyp oder eine bestimmte Region innerhalb einer multiregionalen Instanzkonfiguration oder eine benutzerdefinierte regionale Konfiguration mit optionalen schreibgeschützten Regionen weiterzuleiten.

Gängige Anwendungsfälle

Einige häufige Anwendungsfälle für gerichtete Lesevorgänge sind:

• Load-Balancing von Arbeitslasten über mehrere Regionen, um eine gleichmäßigere CPU-Auslastung zu erreichen
• Isolieren von Analysen in Ihrer Anwendung durch Minimieren der Auswirkungen auf Transaktionsarbeitslasten
• Bereitstellen einer teilweisen Isolierung für Lesevorgänge im Änderungsstream Wenn Sie die Spanner API zum Streamen von Spanner-Datenänderungen verwenden, können Sie die Auswirkungen auf Transaktionsarbeitslasten mithilfe von gerichteten Lesevorgängen minimieren.

Unterstützte Abfragevorgänge

Abfragevorgänge	Werden gerichtete Lesevorgänge unterstützt?
Veraltete Lesevorgänge	Ja
Starke Lesekompetenz	Ja
Lese-Schreib-Transaktion	Nein

Gerichtete Lesevorgänge werden für Lese-Schreib-Transaktionen und partitionierte DML-Typen von Bulk-Updates nicht unterstützt. Dies liegt daran, dass Lese-/Schreibtransaktionen in der führenden Region verarbeitet werden müssen. Wenn gerichtete Lesevorgänge in einer Lese-Schreib-Transaktion verwendet werden, schlägt die Transaktion mit dem Fehler BAD_REQUEST fehl.

Beschränkungen

Für gerichtete Spanner-Lesevorgänge gelten die folgenden Einschränkungen:

• Sie können gerichtete Lesevorgänge nur in einer Spanner-Instanz in einer multiregionalen Instanzkonfiguration oder einer benutzerdefinierten regionalen Konfiguration mit optionalen schreibgeschützten Regionen verwenden.
• Sie können keine gerichteten Lesevorgänge mit Lese-/Schreibanfragen verwenden, da Schreibanfragen immer von der führenden Region verarbeitet werden.
• Sie können in der Google Cloud Console oder der Google Cloud CLI keine gerichteten Lesevorgänge verwenden. Sie ist mit der REST API und der RPC API sowie mit den Spanner-Clientbibliotheken verfügbar.
• Sie können maximal 10 Replikate in einem einzelnen gerichteten Lesevorgang angeben.
• Wenn Sie das Dashboard für Systemstatistiken oder den Metrics Explorer verwenden, sehen Sie in den Diagrammen „Vorgänge pro Sekunde“, „Vorgänge pro Sekunde nach Datenbank“ und „Vorgänge pro Sekunde nach API-Methode“ möglicherweise Ihre Anfrage für gerichtete Lesevorgänge an einem anderen Ort als dem von Ihnen angegebenen. In diesem Fall könnten die Informationen aus den Diagrammen falsch sein. Mit den CPU-Auslastungsmesswerten können Sie prüfen, ob Ihre Leseanfragen an die von Ihnen ausgewählten Regionen weitergeleitet werden. Diese Messwerte zeigen die genauesten Informationen dazu, wohin der Traffic für gerichtete Lesevorgänge weitergeleitet wird.

Hinweise

Beachten Sie Folgendes, bevor Sie gerichtete Lesevorgänge verwenden:

• Die Anwendung kann zusätzliche Latenz verursachen, wenn Sie Lesevorgänge an ein Replikat oder eine Region weiterleiten, die nicht der Anwendung am nächsten ist.
• Sie können Traffic basierend auf folgenden Kriterien weiterleiten:
  • Name der Region (z. B. us-central1).
  • Replikattyp (Mögliche Werte: READ_ONLY und READ_WRITE).
• Die Option für automatische Failovers ist bei weitergeleiteten Lesevorgängen standardmäßig aktiviert. Wenn die Option für den automatischen Failover aktiviert ist und alle angegebenen Replikate nicht verfügbar oder fehlerhaft sind, leitet Spanner Anfragen an ein Replikat außerhalb der includeReplicas-Liste weiter. Wenn Sie die Option für automatisches Failover deaktivieren und alle angegebenen Replikate nicht verfügbar oder fehlerhaft sind, schlägt die Anfrage für gerichtete Lesevorgänge fehl.

Parameter für gerichtete Lesevorgänge

Wenn Sie die REST API oder die RPC API für gerichtete Lesevorgänge verwenden, müssen Sie diese Felder im Parameter directedReadOptions definieren. Sie können nur includeReplicas oder excludeReplicas angeben, nicht beides.

• includeReplicas: enthält einen wiederholten Satz von replicaSelections. Diese Liste gibt die Reihenfolge an, in der weitergeleitete Lesevorgänge in bestimmte Regionen oder Replikattypen berücksichtigt werden sollen. Sie können maximal 10 includeReplicas angeben.
  • replicaSelections: Besteht aus location oder Replikat type, das die Anfrage für gerichtete Lesevorgänge verarbeitet. Wenn Sie includeReplicas verwenden, müssen Sie mindestens eines der folgenden Felder angeben:
    • location: Der Standort, der die Anfrage für gerichtete Lesevorgänge bedient. Der Standort muss eine der Regionen in der multiregionalen Konfiguration Ihrer Datenbank sein. Wenn der Standort keine der Regionen in der multiregionalen Konfiguration Ihrer Datenbank ist, werden Anfragen nicht wie erwartet weitergeleitet. Stattdessen werden sie von der nächstgelegenen Region bedient. Beispielsweise können Sie Lesevorgänge zum Speicherort us-central1 in einer Datenbank in der multiregionalen Instanzkonfiguration nam6 weiterleiten.
    • type: Der Replikattyp, der die Anfrage für gerichtete Lesevorgänge verarbeitet. Mögliche Typen sind READ_WRITE und READ_ONLY.
  • autoFailoverDisabled: Standardmäßig ist diese Einstellung auf False gesetzt, was bedeutet, dass automatisches Failover aktiviert ist. Wenn die Option für das automatische Failover aktiviert ist und alle angegebenen Replikate nicht verfügbar oder fehlerhaft sind, leitet Spanner Anfragen an ein Replikat außerhalb der includeReplicas-Liste weiter. Wenn Sie die Option für automatisches Failover deaktivieren und alle angegebenen Replikate nicht verfügbar oder fehlerhaft sind, schlägt die Anfrage für gerichtete Lesevorgänge fehl. Mögliche Werte sind TRUE für deaktiviert und FALSE für aktiviert.
• excludeReplicas: enthält einen wiederholten Satz von replicaSelections, der von der Verarbeitung von Anfragen ausgeschlossen ist. Spanner leitet Anfragen nicht an Replikate in dieser Liste weiter.
  • replicaSelections: Der Standort oder Replikattyp, der von der Verarbeitung der Anfrage für gerichtete Lesevorgänge ausgeschlossen ist. Wenn Sie excludeReplicas verwenden, müssen Sie mindestens eines der folgenden Felder angeben:
    • location: Der Standort, der von der Verarbeitung der Anfrage für gerichtete Lesevorgänge ausgeschlossen ist.
    • type: Der Replikattyp, der von der Verarbeitung der gerichteten Leseanfrage ausgeschlossen ist. Mögliche Typen sind READ_WRITE und READ_ONLY.

Um ein Beispiel für den Text einer REST-Anfrage zu sehen, klicken Sie im Abschnitt Gezielte Lesevorgänge verwenden auf den REST-Tab.

Geleitete Lesevorgänge verwenden

Sie können die Spanner-Clientbibliotheken sowie die REST API und die RPC API verwenden, um gerichtete Lesevorgänge auszuführen.

Clientbibliotheken

C++

void DirectedRead(std::string const& project_id, std::string const& instance_id,
                  std::string const& database_id) {
  namespace spanner = ::google::cloud::spanner;

  // Create a client with a DirectedReadOption.
  auto client = spanner::Client(
      spanner::MakeConnection(
          spanner::Database(project_id, instance_id, database_id)),
      google::cloud::Options{}.set<spanner::DirectedReadOption>(
          spanner::ExcludeReplicas({spanner::ReplicaSelection("us-east4")})));

  spanner::SqlStatement select(
      "SELECT SingerId, AlbumId, AlbumTitle FROM Albums");
  using RowType = std::tuple<std::int64_t, std::int64_t, std::string>;

  // A DirectedReadOption on the operation will override the option set
  // at the client level.
  auto rows = client.ExecuteQuery(
      std::move(select),
      google::cloud::Options{}.set<spanner::DirectedReadOption>(
          spanner::IncludeReplicas(
              {spanner::ReplicaSelection(spanner::ReplicaType::kReadWrite)},
              /*auto_failover_disabled=*/true)));
  for (auto& row : spanner::StreamOf<RowType>(rows)) {
    if (!row) throw std::move(row).status();
    std::cout << "SingerId: " << std::get<0>(*row)
              << " AlbumId: " << std::get<1>(*row)
              << " AlbumTitle: " << std::get<2>(*row) << "\n";
  }
  std::cout << "Read completed for [spanner_directed_read]\n";
}

C#

using Google.Cloud.Spanner.Data;
using Google.Cloud.Spanner.V1;
using System.Collections.Generic;
using System.Threading.Tasks;

public class DirectedReadsAsyncSample
{
    public class Album
    {
        public int SingerId { get; set; }
        public int AlbumId { get; set; }
        public string AlbumTitle { get; set; }
    }

    public async Task<List<Album>> DirectedReadsAsync(string projectId, string instanceId, string databaseId)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";
        using var connection = new SpannerConnection(connectionString);

        using var cmd = connection.CreateSelectCommand("SELECT SingerId, AlbumId, AlbumTitle FROM Albums");
        // Set directed read options on a query or read command.
        cmd.DirectedReadOptions = new DirectedReadOptions
        {
            IncludeReplicas = new DirectedReadOptions.Types.IncludeReplicas
            {
                AutoFailoverDisabled = true,
                ReplicaSelections =
                {
                    new DirectedReadOptions.Types.ReplicaSelection
                    {
                        Location = "us-central1",
                        Type = DirectedReadOptions.Types.ReplicaSelection.Types.Type.ReadOnly
                    }
                }
            }
        };

        var albums = new List<Album>();
        using var reader = await cmd.ExecuteReaderAsync();
        while (await reader.ReadAsync())
        {
            albums.Add(new Album
            {
                AlbumId = reader.GetFieldValue<int>("AlbumId"),
                SingerId = reader.GetFieldValue<int>("SingerId"),
                AlbumTitle = reader.GetFieldValue<string>("AlbumTitle")
            });
        }
        return albums;
    }
}

Go

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
	sppb "cloud.google.com/go/spanner/apiv1/spannerpb"
	"google.golang.org/api/iterator"
)

//	Shows how to run a query with directed read options.
//	Only one of ExcludeReplicas or IncludeReplicas can be set
//	Each accepts a list of ReplicaSelections which contains Location and Type
//	* `location` - The location must be one of the regions within the
//	multi-region configuration of your database.
//	* `type` - The type of the replica
//	Some examples of using replica_selectors are:
//	* `location:us-east1` --> The "us-east1" replica(s) of any available type
//		will be used to process the request.
//	* `type:READ_ONLY`    --> The "READ_ONLY" type replica(s) in nearest
//	available location will be used to process the
//	request.
//	* `location:us-east1 type:READ_ONLY` --> The "READ_ONLY" type replica(s)
//	in location "us-east1" will be used to process the request.
//		IncludeReplicas also contains an option for AutoFailoverDisabled which when set
//	Spanner will not route requests to a replica outside the
//	IncludeReplicas list when all the specified replicas are unavailable
//	or unhealthy. The default value is `false`

func directedReadOptions(w io.Writer, db string) error {
	// db = `projects/<project>/instances/<instance-id>/database/<database-id>`
	ctx := context.Background()
	directedReadOptionsForClient := &sppb.DirectedReadOptions{
		Replicas: &sppb.DirectedReadOptions_ExcludeReplicas_{
			ExcludeReplicas: &sppb.DirectedReadOptions_ExcludeReplicas{
				ReplicaSelections: []*sppb.DirectedReadOptions_ReplicaSelection{
					{
						Location: "us-east4",
					},
				},
			},
		},
	}
	// DirectedReadOptions can be set at client level and will be used in all read-only transaction requests
	client, err := spanner.NewClientWithConfig(ctx, db, spanner.ClientConfig{DirectedReadOptions: directedReadOptionsForClient})
	if err != nil {
		return err
	}
	defer client.Close()

	// DirectedReadOptions set at Request level will override the options set at Client level.
	directedReadOptionsForRequest := &sppb.DirectedReadOptions{
		Replicas: &sppb.DirectedReadOptions_IncludeReplicas_{
			IncludeReplicas: &sppb.DirectedReadOptions_IncludeReplicas{
				ReplicaSelections: []*sppb.DirectedReadOptions_ReplicaSelection{
					{
						Type: sppb.DirectedReadOptions_ReplicaSelection_READ_ONLY,
					},
				},
				AutoFailoverDisabled: true,
			},
		},
	}

	statement := spanner.Statement{SQL: `SELECT SingerId, AlbumId, AlbumTitle FROM Albums`}
	// // Read rows while passing directedReadOptions directly to the query.
	iter := client.Single().QueryWithOptions(ctx, statement, spanner.QueryOptions{DirectedReadOptions: directedReadOptionsForRequest})
	defer iter.Stop()
	for {
		row, err := iter.Next()
		if err == iterator.Done {
			return nil
		}
		if err != nil {
			return err
		}
		var singerID, albumID int64
		var albumTitle string
		if err := row.Columns(&singerID, &albumID, &albumTitle); err != nil {
			return err
		}
		fmt.Fprintf(w, "%d %d %s\n", singerID, albumID, albumTitle)
	}
}

Java

import com.google.cloud.spanner.DatabaseClient;
import com.google.cloud.spanner.DatabaseId;
import com.google.cloud.spanner.Options;
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 com.google.spanner.v1.DirectedReadOptions;
import com.google.spanner.v1.DirectedReadOptions.ExcludeReplicas;
import com.google.spanner.v1.DirectedReadOptions.IncludeReplicas;
import com.google.spanner.v1.DirectedReadOptions.ReplicaSelection;

public class DirectedReadSample {
  static void directedRead() {
    // TODO(developer): Replace these variables before running the sample.
    final String projectId = "my-project";
    final String instanceId = "my-instance";
    final String databaseId = "my-database";
    directedRead(projectId, instanceId, databaseId);
  }

  static void directedRead(String projectId, String instanceId, String databaseId) {
    // Only one of excludeReplicas or includeReplicas can be set
    // Each accepts a list of replicaSelections which contains location and type
    //   * `location` - The location must be one of the regions within the
    //      multi-region configuration of your database.
    //   * `type` - The type of the replica
    // Some examples of using replicaSelectors are:
    //   * `location:us-east1` --> The "us-east1" replica(s) of any available type
    //                             will be used to process the request.
    //   * `type:READ_ONLY`    --> The "READ_ONLY" type replica(s) in nearest
    // .                            available location will be used to process the
    //                             request.
    //   * `location:us-east1 type:READ_ONLY` --> The "READ_ONLY" type replica(s)
    //                          in location "us-east1" will be used to process
    //                          the request.
    //  includeReplicas also contains an option called autoFailoverDisabled, which when set to true
    //  will instruct Spanner to not route requests to a replica outside the
    //  includeReplicas list when all the specified replicas are unavailable
    //  or unhealthy. Default value is `false`.
    final DirectedReadOptions directedReadOptionsForClient =
        DirectedReadOptions.newBuilder()
            .setExcludeReplicas(
                ExcludeReplicas.newBuilder()
                    .addReplicaSelections(
                        ReplicaSelection.newBuilder().setLocation("us-east4").build())
                    .build())
            .build();

    // You can set default `DirectedReadOptions` for a Spanner client. These options will be applied
    // to all read-only transactions that are executed by this client, unless specific
    // DirectedReadOptions are set for a query.
    // Directed read can only be used for read-only transactions. The default options will be
    // ignored for any read/write transaction that the client executes.
    try (Spanner spanner =
        SpannerOptions.newBuilder()
            .setProjectId(projectId)
            .setDirectedReadOptions(directedReadOptionsForClient)
            .build()
            .getService()) {
      final DatabaseClient dbClient =
          spanner.getDatabaseClient(DatabaseId.of(projectId, instanceId, databaseId));

      // DirectedReadOptions at request level will override the options set at
      // client level (through SpannerOptions).
      final DirectedReadOptions directedReadOptionsForRequest =
          DirectedReadOptions.newBuilder()
              .setIncludeReplicas(
                  IncludeReplicas.newBuilder()
                      .addReplicaSelections(
                          ReplicaSelection.newBuilder()
                              .setType(ReplicaSelection.Type.READ_WRITE)
                              .build())
                      .setAutoFailoverDisabled(true)
                      .build())
              .build();

      // Read rows while passing DirectedReadOptions directly to the query.
      try (ResultSet rs =
          dbClient
              .singleUse()
              .executeQuery(
                  Statement.of("SELECT SingerId, AlbumId, AlbumTitle FROM Albums"),
                  Options.directedRead(directedReadOptionsForRequest))) {
        while (rs.next()) {
          System.out.printf(
              "SingerId: %d, AlbumId: %d, AlbumTitle: %s\n",
              rs.getLong(0), rs.getLong(1), rs.getString(2));
        }
        System.out.println("Successfully executed read-only transaction with directedReadOptions");
      }
    }
  }
}

Node.js

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

// Only one of excludeReplicas or includeReplicas can be set
// Each accepts a list of replicaSelections which contains location and type
//   * `location` - The location must be one of the regions within the
//      multi-region configuration of your database.
//   * `type` - The type of the replica
// Some examples of using replicaSelectors are:
//   * `location:us-east1` --> The "us-east1" replica(s) of any available type
//                             will be used to process the request.
//   * `type:READ_ONLY`    --> The "READ_ONLY" type replica(s) in nearest
//.                            available location will be used to process the
//                             request.
//   * `location:us-east1 type:READ_ONLY` --> The "READ_ONLY" type replica(s)
//                          in location "us-east1" will be used to process
//                          the request.
//  includeReplicas also contains an option for autoFailover which when set
//  Spanner will not route requests to a replica outside the
//  includeReplicas list when all the specified replicas are unavailable
//  or unhealthy. The default value is `false`
const directedReadOptionsForClient = {
  excludeReplicas: {
    replicaSelections: [
      {
        location: 'us-east4',
      },
    ],
  },
};

// Instantiates a client with directedReadOptions
const spanner = new Spanner({
  projectId: projectId,
  directedReadOptions: directedReadOptionsForClient,
});

async function spannerDirectedReads() {
  // Gets a reference to a Cloud Spanner instance and backup
  const instance = spanner.instance(instanceId);
  const database = instance.database(databaseId);
  const directedReadOptionsForRequest = {
    includeReplicas: {
      replicaSelections: [
        {
          type: protos.google.spanner.v1.DirectedReadOptions.ReplicaSelection
            .Type.READ_ONLY,
        },
      ],
      autoFailoverDisabled: true,
    },
  };

  await database.getSnapshot(async (err, transaction) => {
    if (err) {
      console.error(err);
      return;
    }
    try {
      // Read rows while passing directedReadOptions directly to the query.
      // These will override the options passed at Client level.
      const [rows] = await transaction.run({
        sql: 'SELECT SingerId, AlbumId, AlbumTitle FROM Albums',
        directedReadOptions: directedReadOptionsForRequest,
      });
      rows.forEach(row => {
        const json = row.toJSON();
        console.log(
          `SingerId: ${json.SingerId}, AlbumId: ${json.AlbumId}, AlbumTitle: ${json.AlbumTitle}`
        );
      });
      console.log(
        'Successfully executed read-only transaction with directedReadOptions'
      );
    } catch (err) {
      console.error('ERROR:', err);
    } finally {
      transaction.end();
      // Close the database when finished.
      await database.close();
    }
  });
}
spannerDirectedReads();

PHP

use Google\Cloud\Spanner\SpannerClient;
use Google\Cloud\Spanner\V1\DirectedReadOptions\ReplicaSelection\Type as ReplicaType;

/**
 * Queries sample data from the database with directed read options.
 * Example:
 * ```
 * directed_read($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function directed_read(string $instanceId, string $databaseId): void
{
    $directedReadOptionsForClient = [
        'directedReadOptions' => [
            'excludeReplicas' => [
                'replicaSelections' => [
                    [
                        'location' => 'us-east4'
                    ]
                ]
            ]
        ]
    ];

    $directedReadOptionsForRequest = [
        'directedReadOptions' => [
            'includeReplicas' => [
                'replicaSelections' => [
                    [
                        'type' => ReplicaType::READ_WRITE
                    ]
                ],
                'autoFailoverDisabled' => true
            ]
        ]
    ];

    $spanner = new SpannerClient($directedReadOptionsForClient);
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);
    $snapshot = $database->snapshot();

    // directedReadOptions at Request level will override the options set at
    // Client level
    $results = $snapshot->execute(
        'SELECT SingerId, AlbumId, AlbumTitle FROM Albums',
        $directedReadOptionsForRequest
    );

    foreach ($results as $row) {
        printf('SingerId: %s, AlbumId: %s, AlbumTitle: %s' . PHP_EOL,
            $row['SingerId'], $row['AlbumId'], $row['AlbumTitle']);
    }
}

Python

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"

directed_read_options_for_client = {
    "exclude_replicas": {
        "replica_selections": [
            {
                "location": "us-east4",
            },
        ],
    },
}

# directed_read_options can be set at client level and will be used in all
# read-only transaction requests
spanner_client = spanner.Client(
    directed_read_options=directed_read_options_for_client
)
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

directed_read_options_for_request = {
    "include_replicas": {
        "replica_selections": [
            {
                "type_": DirectedReadOptions.ReplicaSelection.Type.READ_ONLY,
            },
        ],
        "auto_failover_disabled": True,
    },
}

with database.snapshot() as snapshot:
    # Read rows while passing directed_read_options directly to the query.
    # These will override the options passed at Client level.
    results = snapshot.execute_sql(
        "SELECT SingerId, AlbumId, AlbumTitle FROM Albums",
        directed_read_options=directed_read_options_for_request,
    )

    for row in results:
        print("SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))

Ruby

require "google/cloud/spanner"

##
# This is a snippet for showcasing how to pass in directed read 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_directed_read project_id:, instance_id:, database_id:
  # Only one of exclude_replicas or include_replicas can be set.
  # Each accepts a list of replica_selections which contains location and type
  #   * `location` - The location must be one of the regions within the
  #      multi-region configuration of your database.
  #   * `type` - The type of the replica
  # Some examples of using replicaSelectors are:
  #   * `location:us-east1` --> The "us-east1" replica(s) of any available type
  #                             will be used to process the request.
  #   * `type:READ_ONLY`    --> The "READ_ONLY" type replica(s) in the nearest
  # .                            available location will be used to process the
  #                             request.
  #   * `location:us-east1 type:READ_ONLY` --> The "READ_ONLY" type replica(s)
  #                          in location "us-east1" will be used to process
  #                          the request.
  #  include_replicas also contains an option for auto_failover_disabled. If set
  #  Spanner will not route requests to a replica outside the
  #  include_replicas list even if all the specified replicas are
  #  unavailable or unhealthy. The default value is `false`.
  directed_read_options_for_client = {
    include_replicas: {
      replica_selections: [{ location: "us-east4" }]
    }
  }

  # Instantiates a client with directedReadOptions
  spanner = Google::Cloud::Spanner.new project: project_id
  client  = spanner.client instance_id, database_id, directed_read_options: directed_read_options_for_client

  directed_read_options = {
    include_replicas: {
      replica_selections: [{ type: "READ_WRITE" }],
      auto_failover_disabled: true
    }
  }

  result = client.execute_sql "SELECT SingerId, AlbumId, AlbumTitle FROM Albums", directed_read_options: directed_read_options
  result.rows.each do |row|
    puts "SingerId: #{row[:SingerId]}"
    puts "AlbumId: #{row[:AlbumId]}"
    puts "AlbumTitle: #{row[:AlbumTitle]}"
  end
  puts "Successfully executed read-only transaction with directed_read_options"
end

REST

Sie können die folgenden REST APIs verwenden, um gerichtete Lesevorgänge auszuführen:

• executeSql
• executeStreamingSql
• read
• streamingRead

So führen Sie beispielsweise direkte Lesevorgänge in us-central1 mit executeSQL aus:

1. Klicken Sie auf projects.instances.databases.sessions.executeSql.

2. Geben Sie für session (Sitzung) Folgendes ein:

   projects/<VAR>PROJECT-ID</VAR>/instances/<VAR>INSTANCE-ID</VAR>/databases/<VAR>DATABASE-ID</VAR>/sessions/<VAR>SESSION-ID</VAR>
   

   Ersetzen Sie Folgendes:

   • PROJECT-ID: Projekt-ID.
   • INSTANCE-ID: Instanz-ID.
   • DATABASE-ID: die Datenbank-ID.
   • SESSION-ID: die Sitzungs-ID. Sie erhalten den Wert SESSION-ID, wenn Sie eine Sitzung erstellen.

3. Verwenden Sie Folgendes für Request body (Requesttext):

   {
     "directedReadOptions": {
       "includeReplicas": {
         "replicaSelections": [
           {
             "location": "us-central1",
           }
         ]
       }
     },
     "sql": "SELECT SingerId, AlbumId, AlbumTitle FROM Albums"
   }
   

4. Klicken Sie auf Execute (Ausführen). In der Antwort werden die Abfrageergebnisse angegeben.

RPC

Sie können die folgenden RPC APIs verwenden, um gerichtete Lesevorgänge auszuführen:

• ExecuteSql
• ExecuteStreamingSql
• Read
• StreamingRead

Nächste Schritte

• Lesen Sie hier, wie Sie Lesevorgänge außerhalb von Transaktionen ausführen.