방향성 읽기

이 페이지에서는 Spanner 방향성 읽기와 사용 방법을 설명합니다.

Spanner의 방향성 읽기는 멀티 리전 인스턴스 구성 또는 선택적 읽기 전용 리전이 있는 커스텀 리전 구성 내에서 읽기 전용 트랜잭션과 단일 읽기를 특정 복제본 유형 또는 리전으로 라우팅할 수 있는 유연성을 제공합니다.

이점

방향성 읽기에는 다음과 같은 이점이 있습니다.

• 여러 리전에서 부하 분산 워크로드를 더 효과적으로 제어하여 보다 균일한 CPU 사용률을 달성하고 Spanner 인스턴스의 오버프로비저닝을 방지합니다.
• 워크로드 격리를 사용 설정합니다. 분석 워크로드와 변경 내역 읽기를 특정 Spanner 복제본으로 전달하여 동일한 Spanner 데이터베이스에서 실행되는 트랜잭션 워크로드에 미치는 영향을 최소화할 수 있습니다.

지원되는 쿼리 작업

쿼리 작업	방향성 읽기가 지원되나요?
비활성 읽기	예
강력한 읽기	예
읽기-쓰기 트랜잭션	아니요

방향성 읽기는 읽기-쓰기 트랜잭션 및 Partitioned DML 유형의 일괄 업데이트에서 지원되지 않습니다. 읽기-쓰기 트랜잭션은 리더 리전에서 처리되어야 하기 때문입니다. 읽기-쓰기 트랜잭션에 방향성 읽기가 사용된 경우 BAD_REQUEST 오류와 함께 트랜잭션이 실패합니다.

제한사항

Spanner 방향성 읽기에는 다음과 같은 제한사항이 있습니다.

• 멀티 리전 인스턴스 구성에 있는 Spanner 인스턴스 또는 선택 사항인 읽기 전용 리전이 있는 커스텀 리전 구성에 있는 Spanner 인스턴스에서만 방향성 읽기를 사용할 수 있습니다.
• 쓰기 요청은 항상 리더 리전에서 제공되므로 읽기-쓰기 요청에 방향성 읽기를 사용할 수 없습니다.
• Google Cloud 콘솔 또는 Google Cloud CLI에서는 방향성 읽기를 사용할 수 없습니다. REST 및 RPC API와 Spanner 클라이언트 라이브러리 사용이 가능합니다.
• 단일 방향성 읽기에서 최대 10개의 복제본을 지정할 수 있습니다.

시작하기 전에

방향성 읽기를 사용하기 전에 다음을 고려하세요.

• 애플리케이션에 가장 가까운 복제본 또는 리전이 아닌 복제본이나 리전으로 읽기를 라우팅하는 경우 애플리케이션에 추가 지연 시간이 발생할 수 있습니다.
• 다음을 기준으로 트래픽을 라우팅할 수 있습니다.
  • 리전 이름입(예: us-central1)
  • 복제본 유형(가능한 값: READ_ONLY 및 READ_WRITE)
• 방향성 읽기의 자동 장애 조치 옵션은 기본적으로 사용 설정되어 있습니다. 자동 장애 조치 옵션이 사용 설정되어 있고 지정된 모든 복제본을 사용할 수 없거나 비정상인 경우 Spanner는 요청을 includeReplicas 목록 외부의 복제본으로 라우팅합니다. 자동 장애 조치 옵션을 사용 중지하고 지정된 모든 복제본을 사용할 수 없거나 비정상이면 방향성 읽기 요청이 실패합니다.

방향성 읽기 파라미터

REST 또는 RPC API를 사용하여 지정된 읽기를 실행하는 경우 directedReadOptions 파라미터에서 이러한 필드를 정의해야 합니다. includeReplicas 또는 excludeReplicas 중 하나만 포함할 수 있으며 둘 다 포함하는 것은 불가능합니다.

• includeReplicas: 반복되는 replicaSelections 집합을 포함합니다. 이 목록은 특정 리전 또는 복제본 유형에 대한 방향성 읽기를 고려해야 하는 순서를 나타냅니다. includeReplicas는 최대 10개까지 지정할 수 있습니다.

  • replicaSelections: 방향성 읽기 요청을 처리하는 location 또는 복제본 type로 구성됩니다. includeReplicas를 사용하는 경우 다음 필드 중 하나 이상을 제공해야 합니다.

    • location: 방향성 읽기 요청을 처리하는 위치입니다. 위치는 데이터베이스의 멀티 리전 구성에 있는 리전 중 하나여야 합니다. 위치가 데이터베이스의 멀티 리전 구성에 있는 리전 중 하나가 아닌 경우 요청이 예상대로 라우팅되지 않습니다. 대신 가장 가까운 리전에서 제공됩니다. 예를 들어 멀티 리전 인스턴스 구성 nam6의 데이터베이스에서 us-central1 위치로 읽기를 전달할 수 있습니다.

      leader 또는 non-leader 문자열 리터럴로 location 파리미터를 지정할 수도 있습니다. leader 값을 입력하면 Spanner는 요청을 데이터베이스의 리더 복제본으로 전달합니다. 반대로 non-leader 값을 입력하면 Spanner는 가장 가까운 비리더 복제본에서 요청을 처리합니다.

    • type: 방향성 읽기 요청을 처리하는 복제본 유형입니다. 가능한 유형은 READ_WRITE, READ_ONLY입니다.

  • autoFailoverDisabled: 기본값은 False로 설정되어 있으며 이는 자동 장애 조치가 사용 설정되어 있음을 의미합니다. 자동 장애 조치 옵션이 사용 설정되어 있고 지정된 모든 복제본을 사용할 수 없거나 비정상인 경우 Spanner는 요청을 includeReplicas 목록 외부의 복제본으로 라우팅합니다. 자동 장애 조치 옵션을 사용 중지하고 지정된 모든 복제본을 사용할 수 없거나 비정상이면 방향성 읽기 요청이 실패합니다. 사용 중지된 경우 TRUE, 사용 설정된 경우 FALSE를 사용할 수 있습니다.

• excludeReplicas: 요청 처리에서 제외되는 반복된 replicaSelections 집합을 포함합니다. Spanner는 이 목록의 복제본으로 요청을 라우팅하지 않습니다.

  • replicaSelections: 방향성 읽기 요청 처리에서 제외되는 위치 또는 복제본 유형입니다. excludeReplicas를 사용하는 경우 다음 필드 중 하나 이상을 제공해야 합니다.
    • location: 방향성 읽기 요청 처리에서 제외되는 위치입니다.
    • type: 방향성 읽기 요청 처리에서 제외되는 복제본 유형입니다. 가능한 유형은 READ_WRITE, READ_ONLY입니다.

REST 요청 본문이 어떤 모습인지 확인하려면 지정된 읽기 사용 섹션의 REST 탭을 클릭합니다.

방향성 읽기 사용

Spanner 클라이언트 라이브러리와 REST 및 RPC API를 사용하여 방향성 읽기를 실행할 수 있습니다.

클라이언트 라이브러리

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)
	}
}

자바

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

다음 REST API를 사용하여 방향성 읽기를 실행할 수 있습니다.

• executeSql
• executeStreamingSql
• read
• streamingRead

예를 들어 executeSQL을 사용하여 us-central1에서 방향성 읽기를 수행하려면 다음을 수행합니다.

1. projects.instances.databases.sessions.executeSql을 클릭합니다.

2. 세션에 다음을 입력합니다.

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

   다음을 바꿉니다.

   • PROJECT-ID: 프로젝트 ID
   • INSTANCE-ID: 인스턴스 ID입니다.
   • DATABASE-ID: 데이터베이스 ID
   • SESSION-ID: 세션 ID. 세션 만들기에서 SESSION-ID 값을 받습니다.

3. 요청 본문에 다음을 사용합니다.

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

4. 실행을 클릭합니다. 이에 대한 응답으로, 쿼리 결과가 표시됩니다.

RPC

다음 RPC API를 사용하여 방향성 읽기를 실행할 수 있습니다.

• ExecuteSql
• ExecuteStreamingSql
• Read
• StreamingRead

모니터링

Spanner는 인스턴스의 지정된 읽기 활동을 모니터링하는 데 도움이 되는 지연 시간 측정항목을 제공합니다. 이 측정항목은 Cloud Monitoring에서 사용할 수 있습니다.

• spanner.googleapis.com/api/read_request_latencies_by_serving_location

/serving_location 또는 /is_directed_read 필드를 사용하여 이 측정항목을 필터링할 수 있습니다. /serving location 필드는 요청이 제공되는 Spanner 서버의 위치를 나타냅니다. /is_directed_read 필드는 지정된 읽기 옵션이 사용 설정되어 있는지 나타냅니다.

사용 가능한 측정항목의 전체 목록은 Spanner 측정항목 목록을 참조하세요.

다음 단계

• 트랜잭션 외부에서 읽기를 실행하는 방법을 알아보세요.