Roteamento com reconhecimento de líder

Nesta página, descrevemos o roteamento com reconhecimento de líder no Spanner e como usá-lo. O Spanner usa roteamento com reconhecimento de líder para rotear dinamicamente transações de leitura/gravação em configurações de instâncias multirregionais para reduzir a latência e melhorar o desempenho do banco de dados. O roteamento com reconhecimento de líder é ativado por padrão.

Roteamento do Spanner para transações de leitura e gravação

O Spanner replica os dados para oferecer mais disponibilidade de dados e localidade geográfica. Nas configurações de instâncias multirregionais do Spanner, uma região na configuração da instância multirregional é designada como a região líder e contém as réplicas líderes do banco de dados. Quando você usa uma configuração de instância multirregional e o cliente emite uma transação de leitura/gravação para o banco de dados a partir de uma região não líder, a gravação é sempre processada na região líder e enviada de volta para a região não líder. Portanto, as transações de leitura/gravação confirmadas em uma região não líder exigem várias idas e voltas para a réplica líder para serem confirmadas.

O roteamento com reconhecimento de líder é um mecanismo que melhora a latência das transações de leitura/gravação roteando essas transações de maneira inteligente. Se o roteamento com reconhecimento de líder estiver ativado, mesmo que a gravação não se origine da região líder, as solicitações de criação de sessão serão roteadas para a região líder para alinhar o Spanner Front End (SpanFE) com a região líder. Esse mecanismo de roteamento melhora a latência das transações de leitura/gravação reduzindo para dois o número de viagens de ida e volta da rede necessárias entre a região não líder (onde o aplicativo cliente está localizado) e a região líder.

Figura 1. Exemplo de roteamento do Spanner com roteamento com reconhecimento de líder ativado.

Se o roteamento com reconhecimento de líder estiver desativado, o aplicativo cliente primeiro encaminhará a solicitação para um serviço SpanFE dentro da região do aplicativo cliente (região não líder). Em seguida, do SpanFE na região do aplicativo cliente, três ou mais viagens de ida e volta são feitas para o servidor do Spanner (SpanServer) na região líder para confirmar a gravação, aumentando a latência. Essas viagens de ida e volta adicionais são necessárias para dar suporte a índices secundários, verificações de restrição e ler suas gravações.

Figura 2. Exemplo de roteamento do Spanner com roteamento com reconhecimento de líder desativado.

Casos de uso

Como resultado do uso do roteamento com reconhecimento de líder, os seguintes casos de uso se beneficiam de uma latência menor:

• Atualizações em massa: execução de importações do Dataflow ou alterações em segundo plano (por exemplo, DMLs em lote) de uma região não líder.
• Tolerância a desastres e maior disponibilidade: implante aplicativos clientes nas regiões líder e não líder para tolerar interrupções regionais ao iniciar gravações em regiões não líderes.
• Aplicativo global: implantação de aplicativos clientes globalmente com locais de região generalizados que confirmam dados.

Limitações

Se o aplicativo cliente for implantado fora da região líder e você gravar valores sem ler os dados ("gravações cegas"),poderá observar a regressão de latência se o roteamento com reconhecimento de líder estiver ativado. Isso ocorre porque, quando o roteamento com reconhecimento de líder está ativado, há duas viagens de ida e volta entre regiões (beginTransaction e commit) entre o aplicativo cliente na região não líder e o SpanFE na região líder. No entanto, com o roteamento com reconhecimento de líder desativado, as gravações sem leituras exigem apenas uma ida e volta entre regiões para a solicitação commit (beginTransaction é processado no SpanFE local). Por exemplo, se você carregar em massa os dados do arquivo em uma tabela recém-criada, é improvável que as transações leiam os dados da tabela. Se você confirma as operações de gravação com frequência sem ler no aplicativo, desative o roteamento com reconhecimento de líder. Para mais informações, consulte Desativar o roteamento com reconhecimento de líder.

Use roteamento com reconhecimento de líderes

O roteamento com reconhecimento de líder é ativado por padrão nas bibliotecas de cliente do Spanner.

Recomendamos processar suas solicitações de leitura/gravação com o roteamento com reconhecimento de líder ativado. É possível desativá-la para comparar diferenças de desempenho.

Ativar o roteamento com reconhecimento de líderes

É possível usar as bibliotecas de cliente do Spanner para ativar manualmente o roteamento com reconhecimento de líder.

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

// Create a client with RouteToLeaderOption enabled.
auto client = spanner::Client(
  spanner::MakeConnection(
      spanner::Database(project_id, instance_id, database_id)),
  google::cloud::Options{}.set<spanner::RouteToLeaderOption>(
      spanner::true));

// Create a client with leader-aware routing enabled.
SpannerConnectionStringBuilder builder = new
SpannerConnectionStringBuilder();
Builder.EnableLeaderRouting = true;

type ClientConfig struct {
    // DisableRouteToLeader specifies if all the requests of type read-write
    // and PDML need to be routed to the leader region.
    // Default: false
    DisableRouteToLeader false
}

SpannerOptions options = SpannerOptions.newBuilder().enableLeaderAwareRouting.build();
Spanner spanner = options.getService();
String instance = "my-instance";
String database = "my-database";

// Instantiates a client with routeToLeaderEnabled enabled
const spanner = new Spanner({
projectId: projectId,
routeToLeaderEnabled: true;
});

// Instantiates a client with leader-aware routing enabled
use Google\Cloud\Spanner\SpannerClient;

$routeToLeader = true;
$spanner = new SpannerClient($routeToLeader);

spanner_client = spanner.Client(
route_to_leader_enabled=true
)
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

def self.new(project_id: nil, credentials: nil, scope: nil, timeout: nil,
     endpoint: nil, project: nil, keyfile: nil, emulator_host: nil,
    lib_name: nil, lib_version: nil, enable_leader_aware_routing: true) ->
    Google::Cloud::Spanner::Project

Desativar o roteamento com reconhecimento de líderes

É possível usar as bibliotecas de cliente do Spanner para desativar o roteamento com reconhecimento de líder.

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

// Create a client with RouteToLeaderOption disabled.
auto client = spanner::Client(
  spanner::MakeConnection(
      spanner::Database(project_id, instance_id, database_id)),
  google::cloud::Options{}.set<spanner::RouteToLeaderOption>(
      spanner::false));

// Create a client with leader-aware routing disabled.
SpannerConnectionStringBuilder builder = new
SpannerConnectionStringBuilder();
Builder.EnableLeaderRouting = false;

type ClientConfig struct {
    // DisableRouteToLeader specifies if all the requests of type read-write
    // and PDML need to be routed to the leader region.
    // Default: false
    DisableRouteToLeader true
}

SpannerOptions options = SpannerOptions.newBuilder().disableLeaderAwareRouting.build();
Spanner spanner = options.getService();
String instance = "my-instance";
String database = "my-database";

// Instantiates a client with routeToLeaderEnabled disabled
const spanner = new Spanner({
projectId: projectId,
routeToLeaderEnabled: false;
});

// Instantiates a client with leader-aware routing disabled
use Google\Cloud\Spanner\SpannerClient;

$routeToLeader = false;
$spanner = new SpannerClient($routeToLeader);

spanner_client = spanner.Client(
route_to_leader_enabled=false
)
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

def self.new(project_id: nil, credentials: nil, scope: nil, timeout: nil,
     endpoint: nil, project: nil, keyfile: nil, emulator_host: nil,
    lib_name: nil, lib_version: nil, enable_leader_aware_routing: false) ->
    Google::Cloud::Spanner::Project

A seguir

• Saiba mais sobre as configurações regionais e multirregionais.
• Saiba mais sobre replicação.
• Saiba como modificar a região líder de um banco de dados.