Nesta página, descrevemos o roteamento com reconhecimento de líder no Spanner e como usá-lo. O Spanner usa o roteamento com reconhecimento de líder para rotear dinamicamente leitura e gravação transações em configurações de instâncias birregionais e multirregionais para reduzir latência e melhorar o desempenho do banco de dados. O roteamento baseado no líder é ativada por padrão.
Roteamento do Spanner para transações de leitura/gravação
O Spanner replica os dados para fornecer mais dados disponibilidade e localidade geográfica. No Spanner configurações de instâncias birregionais e multirregionais, uma região na configuração de instância birregional e multirregional é designada como região líder e contém as réplicas líderes do banco de dados. Quando você usa uma instância birregional ou multirregional e seu cliente emite uma transação de leitura/gravação no seu banco de dados de uma região não líder, a gravação é sempre processada na região líder e enviada de volta à região não líder. Portanto, as transações de leitura e gravação comprometidas em uma região não líder exigem várias viagens de ida e volta ao líder réplica seja confirmada com sucesso.
O roteamento com reconhecimento de líder é um mecanismo que melhora a latência de leitura/gravação e as transações encaminham essas transações de maneira inteligente. Se o líder conhecer o líder o roteamento estiver ativado, mesmo que a gravação não seja originada da região líder, as solicitações de criação de sessão são encaminhadas para a região líder para alinhar Front End do Spanner (SpanFE) com a região líder. Este roteamento mecanismo melhora a latência para transações de leitura/gravação reduzindo o número de viagens de ida e volta da rede necessárias entre a região não líder (quando o cliente o aplicativo está localizado) e a região líder para dois.
Figura 1. Exemplo de roteamento do Spanner com o roteamento ciente do líder ativado.
Se o roteamento ciente do líder estiver desativado, o aplicativo cliente vai rotear a solicitação primeiro para um serviço SpanFE na região do aplicativo cliente (região não líder). Em seguida, do SpanFE na região do aplicativo cliente, são feitas três ou mais viagens de ida e volta para o servidor do Spanner (SpanServer) na região líder para confirmar a gravação, aumentando a latência. Esses são necessárias idas e voltas adicionais para dar suporte a índices secundários, verificações de tempo de atividade e ler suas gravações.
Figura 2. Exemplo de roteamento do Spanner com o roteamento ciente do líder desativado.
Casos de uso
Como resultado do uso do roteamento ciente do 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 de mudanças em segundo plano (por exemplo, DMLs em lote) de uma região que não é líder.
- Tolerância a desastres e maior disponibilidade: implantar aplicativos clientes em regiões líderes e não líderes para tolerar interrupções regionais enquanto inicia gravações em regiões não líderes.
- Aplicativo global: implantação de aplicativos cliente globalmente com locais de região disseminados 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 uma regressão
de latência se o roteamento ciente do 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 a solicitação commit
) entre o aplicativo cliente na região que não é líder
e o SpanFE na região líder. No entanto, com o roteamento ciente do 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 dados de arquivos em massa em uma tabela recém-criada, é improvável que as transações
leiam dados da tabela. Se você faz commit de gravações com frequência
operações sem lê-los no aplicativo, convém considerar
e desativar o roteamento com reconhecimento de líder. Para mais informações, consulte
Desativar o roteamento ciente do líder.
Usar o roteamento com reconhecimento de líder
O roteamento com reconhecimento de líder é ativado por padrão no cliente Spanner bibliotecas.
Recomendamos processar suas solicitações de leitura e gravação com o roteamento ciente do líder ativado. Você pode desativar esse recurso para comparar as diferenças de performance.
Ativar o roteamento com conhecimento do líder
É possível usar as bibliotecas de cliente do Spanner para ativar manualmente o roteamento com suporte ao líder.
C++
Use a estrutura RouteToLeaderOption
para configurar o aplicativo cliente com o roteamento ciente do líder
ativado:
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));
C#
Usar EnableLeaderRouting
para configurar seu aplicativo cliente com o roteamento com reconhecimento de líder ativado:
// Create a client with leader-aware routing enabled.
SpannerConnectionStringBuilder builder = new
SpannerConnectionStringBuilder();
Builder.EnableLeaderRouting = true;
Go
Use ClientConfig
para configurar o aplicativo cliente com o roteamento ciente do líder ativado:
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
}
Java
Use SpannerOptions.Builder
para configurar o aplicativo cliente com o roteamento ciente do líder ativado:
SpannerOptions options = SpannerOptions.newBuilder().enableLeaderAwareRouting.build();
Spanner spanner = options.getService();
String instance = "my-instance";
String database = "my-database";
Node.js
Usar SpannerOptions
para configurar seu aplicativo cliente com o roteamento com reconhecimento de líder ativado:
// Instantiates a client with routeToLeaderEnabled enabled
const spanner = new Spanner({
projectId: projectId,
routeToLeaderEnabled: true;
});
PHP
Use routeToLeader
para configurar o aplicativo cliente com o roteamento ciente do líder ativado:
// Instantiates a client with leader-aware routing enabled
use Google\Cloud\Spanner\SpannerClient;
$routeToLeader = true;
$spanner = new SpannerClient($routeToLeader);
Python
Usar route_to_leader_enabled
para configurar seu aplicativo cliente com o roteamento com reconhecimento de líder ativado:
spanner_client = spanner.Client(
route_to_leader_enabled=true
)
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)
Ruby
Usar self.new
para configurar seu aplicativo cliente com o roteamento com reconhecimento de líder ativado:
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íder
É possível usar as bibliotecas de cliente do Spanner para desativar o reconhecimento de líderes e roteamento de alto desempenho.
C++
Usar o RouteToLeaderOption
para configurar seu aplicativo cliente com roteamento baseado em líder
desativado:
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));
C#
Usar EnableLeaderRouting
para configurar seu aplicativo cliente com o roteamento com reconhecimento de líder desativado:
// Create a client with leader-aware routing disabled.
SpannerConnectionStringBuilder builder = new
SpannerConnectionStringBuilder();
Builder.EnableLeaderRouting = false;
Go
Use ClientConfig
para configurar o aplicativo cliente com o roteamento ciente do líder desativado:
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
}
Java
Usar SpannerOptions.Builder
para criar uma conexão com um banco de dados do Spanner
roteamento com reconhecimento desativado:
SpannerOptions options = SpannerOptions.newBuilder().disableLeaderAwareRouting.build();
Spanner spanner = options.getService();
String instance = "my-instance";
String database = "my-database";
Node.js
Usar SpannerOptions
para configurar seu aplicativo cliente com o roteamento com reconhecimento de líder desativado:
// Instantiates a client with routeToLeaderEnabled disabled
const spanner = new Spanner({
projectId: projectId,
routeToLeaderEnabled: false;
});
PHP
Usar o routeToLeader
para configurar seu aplicativo cliente com o roteamento com reconhecimento de líder desativado:
// Instantiates a client with leader-aware routing disabled
use Google\Cloud\Spanner\SpannerClient;
$routeToLeader = false;
$spanner = new SpannerClient($routeToLeader);
Python
Usar route_to_leader_enabled
para configurar seu aplicativo cliente com o roteamento com reconhecimento de líder desativado:
spanner_client = spanner.Client(
route_to_leader_enabled=false
)
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)
Ruby
Use self.new
para configurar o aplicativo cliente com o roteamento ciente do líder desativado:
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 os locais regionais, birregionais e multirregionais personalizadas.
- Saiba mais sobre replicação.
- Saiba como modificar a região líder de um banco de dados.