방향성 읽기

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

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

일반 사용 사례

방향성 읽기의 일반적인 사용 사례는 다음과 같습니다.

  • 여러 리전에 워크로드를 부하 분산하여 보다 균일한 CPU 사용률을 달성합니다.
  • 트랜잭션 워크로드에 미치는 영향을 최소화하여 애플리케이션에서 분석을 격리합니다.
  • 변경 내역 읽기에 부분적인 격리를 제공합니다. Spanner API를 사용하여 Spanner 데이터 변경사항을 스트리밍하는 경우 방향성 읽기를 사용하면 트랜잭션 워크로드에 미치는 영향을 최소화할 수 있습니다.

지원되는 쿼리 작업

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

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

제한사항

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

  • 멀티 리전 인스턴스 구성에 있는 Spanner 인스턴스 또는 선택 사항인 읽기 전용 리전이 있는 커스텀 리전 구성에 있는 Spanner 인스턴스에서만 방향성 읽기를 사용할 수 있습니다.
  • 쓰기 요청은 항상 리더 리전에서 제공되므로 읽기-쓰기 요청에 방향성 읽기를 사용할 수 없습니다.
  • Google Cloud 콘솔 또는 Google Cloud CLI에서는 방향성 읽기를 사용할 수 없습니다. REST, RPC API, Spanner 클라이언트 라이브러리를 사용하여 사용할 수 있습니다.
  • 단일 방향성 읽기에서 최대 10개의 복제본을 지정할 수 있습니다.
  • 시스템 통계 대시보드 또는 측정항목 탐색기를 사용하는 경우 초당 작업 수, 데이터베이스별 초당 작업 수, API 메서드 차트별 초당 작업 수에 따라 지정된 위치가 아닌 다른 위치에 방향성 읽기 요청이 표시될 수 있습니다. 이 경우 차트의 정보가 잘못될 수 있습니다. CPU 사용률 측정항목을 사용하여 읽기 요청이 선택한 리전으로 라우팅되는지 확인할 수 있습니다. 이 측정항목은 방향성 읽기 트래픽이 라우팅되는 위치에 대한 가장 정확한 정보를 보여줍니다.

시작하기 전에

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

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

방향성 읽기 매개변수

REST 또는 RPC API를 사용하여 방향성 읽기를 수행하는 경우 directedReadOptions 매개변수에 이러한 필드를 정의해야 합니다. includeReplicas 또는 excludeReplicas 중 하나만 포함할 수 있으며, 둘 다 포함할 수는 없습니다.

  • includeReplicas: 반복되는 replicaSelections 집합을 포함합니다. 이 목록은 특정 리전 또는 복제본 유형에 대한 방향성 읽기를 고려해야 하는 순서를 나타냅니다. 최대 10개의 includeReplicas를 지정할 수 있습니다.
    • replicaSelections: 방향성 읽기 요청을 제공하는 location 또는 복제본 type으로 구성됩니다. includeReplicas를 사용하는 경우에는 다음 필드 중 하나 이상을 제공해야 합니다.
      • location: 방향성 읽기 요청을 처리하는 위치입니다. 이 위치는 데이터베이스의 멀티 리전 구성에 있는 리전 중 하나여야 합니다. 위치가 데이터베이스의 멀티 리전 구성 내 리전 중 하나가 아닌 경우 요청이 예상대로 라우팅되지 않습니다. 대신 가장 가까운 리전에서 제공됩니다. 예를 들어 멀티 리전 인스턴스 구성 nam6의 데이터베이스에 있는 us-central1 위치로 읽기를 전달할 수 있습니다.
      • 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)
	}
}

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

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

예를 들어 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를 사용하여 방향성 읽기를 수행할 수 있습니다.

다음 단계