Gerenciar réplicas de leitura

Este guia explica como criar e gerenciar réplicas de leitura para seus projetos. As réplicas de leitura separam o trabalho somente leitura de suas operações de banco de dados de produção, com aplicações que variam desde o dimensionamento horizontal até cargas de trabalho de análise. Para obter informações detalhadas sobre a arquitetura de réplicas de leitura e casos de uso, confira Réplicas de leitura.

Noções básicas sobre réplicas de leitura

As réplicas de leitura permitem criar uma ou mais instâncias de leitura para qualquer ramificação em seu projeto. Você pode configurar o tamanho dos recursos de computação alocados para cada réplica. Há suporte para os recursos de dimensionamento automático e dimensionamento para zero, permitindo que você controle o uso da computação de réplicas de leitura.

As etapas para criar, configurar e se conectar a uma réplica de leitura são as mesmas, seja qual for o uso.

Na API e em SDKs, uma réplica de leitura é um ponto de extremidade com endpoint_type definido como ENDPOINT_TYPE_READ_ONLY.

Suporte à região

O Lakebase dá suporte à criação de réplicas de leitura na mesma região que o seu projeto. Não há suporte a réplicas de leitura entre regiões.

Sincronização de configuração de computação

Para réplicas de leitura do Lakebase, certas configurações do Postgres não devem ter valores mais baixos do que a computação de leitura/gravação primária. Por esse motivo, as seguintes configurações em computações de réplica de leitura são sincronizadas com as configurações na computação de leitura/gravação primária quando a computação de réplica de leitura é iniciada:

• max_connections
• max_prepared_transactions
• max_locks_per_transaction
• max_wal_senders
• max_worker_processes

Não é necessária nenhuma ação do usuário. As configurações são sincronizadas automaticamente quando você cria uma réplica de leitura. No entanto, se você alterar a configuração de tamanho de computação na computação de leitura/gravação primária, será necessário reiniciar seus cálculos de réplica de leitura para garantir que as configurações permaneçam sincronizadas. Consulte Solucionar problemas de atraso de replicação para obter mais informações.

Criar e gerenciar réplicas de leitura

Limits

• Máximo de 6 réplicas de leitura por ramificação.
• As réplicas de leitura contam para o limite do projeto de 20 instâncias de computação ativas ao mesmo tempo. Consulte limites do projeto.

Pré-requisitos

• Um projeto do Lakebase. Consulte Criar um projeto.

Criar uma réplica de leitura

Para criar uma réplica de leitura:

interface do usuário

1. No aplicativo do Lakebase, navegue até seu projeto, ramificação e a guia Computações.
2. Clique em Adicionar Réplica de Leitura.
3. Insira um nome para sua réplica de leitura, defina as configurações de computação (intervalo de dimensionamento automático e comportamento de dimensionamento para zero), e clique em Adicionar.

SDK do Python

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Endpoint, EndpointSpec, EndpointType

w = WorkspaceClient()

# Create read replica endpoint (READ_ONLY)
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_ONLY,
    autoscaling_limit_max_cu=2.0
)

endpoint = Endpoint(spec=endpoint_spec)

result = w.postgres.create_endpoint(
    parent="projects/my-project/branches/production",
    endpoint=endpoint,
    endpoint_id="my-read-replica"
).wait()

print(f"Endpoint created: {result.name}")
print(f"Host: {result.status.hosts.host}")

SDK do Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;

WorkspaceClient w = new WorkspaceClient();

// Create read replica endpoint (READ_ONLY)
EndpointSpec endpointSpec = new EndpointSpec()
    .setEndpointType(EndpointType.ENDPOINT_TYPE_READ_ONLY)
    .setAutoscalingLimitMaxCu(2.0);

Endpoint endpoint = new Endpoint()
    .setSpec(endpointSpec);

Endpoint result = w.postgres().createEndpoint(
    new CreateEndpointRequest()
        .setParent("projects/my-project/branches/production")
        .setEndpoint(endpoint)
        .setEndpointId("my-read-replica")
).waitForCompletion();

System.out.println("Endpoint created: " + result.getName());
System.out.println("Host: " + result.getStatus().getHosts().getHost());

CLI

# Create a read replica for a branch
databricks postgres create-endpoint projects/my-project/branches/production my-read-replica \
  --json '{
    "spec": {
      "endpoint_type": "ENDPOINT_TYPE_READ_ONLY",
      "autoscaling_limit_min_cu": 0.5,
      "autoscaling_limit_max_cu": 4.0
    }
  }'

curl

curl -X POST "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints?endpoint_id=my-read-replica" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "spec": {
      "endpoint_type": "ENDPOINT_TYPE_READ_ONLY",
      "autoscaling_limit_min_cu": 0.5,
      "autoscaling_limit_max_cu": 4.0
    }
  }' | jq

Sua réplica de leitura é provisionada em alguns segundos e aparece na guia Computações da ramificação.

Exibir réplicas de leitura

Para exibir réplicas de leitura de uma ramificação, navegue até o projeto no Aplicativo Lakebase, selecione uma ramificação na página Ramificações e exiba a guia Computações em que todos os cálculos de réplica de leitura estão listados.

Conectar a uma réplica de leitura

Conectar-se a uma réplica de leitura segue o mesmo processo de conexão com sua computação de leitura/gravação primária, exceto que você seleciona uma computação de réplica de leitura ao obter informações de conexão.

Para obter informações de conexão para uma réplica de leitura:

1. No Aplicativo Lakebase, clique em Conectar no painel do projeto.
2. Selecione a ramificação, o banco de dados, a função e a computação de réplica de leitura na lista suspensa Computação e copie a cadeia de conexão fornecida.

Você pode se conectar usando uma função OAuth Postgres, da mesma forma que faria com sua computação de leitura/gravação primária.

Para obter informações completas sobre métodos de autenticação e opções de conexão, consulte Conectar-se ao seu projeto.

Editar uma réplica de leitura

Você pode editar uma réplica de leitura para alterar o tamanho da computação ou a configuração de dimensionamento para zero.

Para editar uma réplica de leitura:

interface do usuário

1. Navegue até a guia Computes da sua filial no aplicativo Lakebase.
2. Localize a réplica de leitura, clique em Editar, atualize as configurações de computação e clique em Salvar.

SDK do Python

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Endpoint, EndpointSpec, EndpointType, FieldMask

w = WorkspaceClient()

# Update read replica size
endpoint_name = "projects/my-project/branches/production/endpoints/my-read-replica"

endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_ONLY,
    autoscaling_limit_min_cu=1.0,
    autoscaling_limit_max_cu=8.0
)
endpoint = Endpoint(name=endpoint_name, spec=endpoint_spec)
update_mask = FieldMask(field_mask=[
    "spec.autoscaling_limit_min_cu",
    "spec.autoscaling_limit_max_cu"
])

result = w.postgres.update_endpoint(
    name=endpoint_name,
    endpoint=endpoint,
    update_mask=update_mask
).wait()

print(f"Updated read replica size: {result.status.autoscaling_limit_min_cu}-{result.status.autoscaling_limit_max_cu} CU")

SDK do Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;
import com.google.protobuf.FieldMask;

WorkspaceClient w = new WorkspaceClient();

// Update read replica size
String endpointName = "projects/my-project/branches/production/endpoints/my-read-replica";

EndpointSpec endpointSpec = new EndpointSpec()
    .setAutoscalingLimitMinCu(1.0)
    .setAutoscalingLimitMaxCu(8.0);

FieldMask updateMask = FieldMask.newBuilder()
    .addPaths("spec.autoscaling_limit_min_cu")
    .addPaths("spec.autoscaling_limit_max_cu")
    .build();

w.postgres().updateEndpoint(
    new UpdateEndpointRequest()
        .setName(endpointName)
        .setEndpoint(new Endpoint().setSpec(endpointSpec))
        .setUpdateMask(updateMask)
);

System.out.println("Update initiated");

CLI

# Update a read replica's autoscaling settings
databricks postgres update-endpoint projects/my-project/branches/production/endpoints/my-read-replica "spec.autoscaling_limit_min_cu,spec.autoscaling_limit_max_cu" \
  --json '{
    "spec": {
      "autoscaling_limit_min_cu": 1.0,
      "autoscaling_limit_max_cu": 8.0
    }
  }'

curl

# Update a read replica's autoscaling settings
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-read-replica?update_mask=spec.autoscaling_limit_min_cu,spec.autoscaling_limit_max_cu" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-read-replica",
    "spec": {
      "autoscaling_limit_min_cu": 1.0,
      "autoscaling_limit_max_cu": 8.0
    }
  }' | jq

Saiba mais: Gerenciar cálculos

Excluir uma réplica de leitura

Excluir uma réplica de leitura é uma ação permanente. Mas, você poderá criar rapidamente uma nova réplica de leitura se precisar de uma.

Para excluir uma réplica de leitura:

interface do usuário

1. Navegue até a guia Computes da sua filial no aplicativo Lakebase.
2. Localize a réplica de leitura, clique em Editar, Excluir e confirme a exclusão.

SDK do Python

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# Delete endpoint
w.postgres.delete_endpoint(
    name="projects/my-project/branches/production/endpoints/my-read-replica"
).wait()

print("Endpoint deleted")

A operação de exclusão é assíncrona. O .wait() método bloqueia até que a exclusão seja concluída.

SDK do Java

import com.databricks.sdk.WorkspaceClient;

WorkspaceClient w = new WorkspaceClient();

// Delete endpoint
w.postgres().deleteEndpoint(
    "projects/my-project/branches/production/endpoints/my-read-replica"
);

System.out.println("Delete initiated");

CLI

# Delete a read replica
databricks postgres delete-endpoint projects/my-project/branches/production/endpoints/my-read-replica

curl

curl -X DELETE "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-read-replica" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Resposta:

{
  "name": "projects/my-project/branches/production/endpoints/my-read-replica/operations/...",
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.protobuf.Empty"
  }
}

Solucionar problemas de atraso de replicação

Se as réplicas de leitura estiverem atrasadas, siga estas etapas para diagnosticar e resolver o problema:

Verificar o alinhamento da configuração

Se o atraso de replicação for detectado, verifique se as configurações para os cálculos de réplica primária e de leitura estão alinhadas. Especificamente, confirme se os seguintes parâmetros correspondem entre a computação primária e a computação de réplica de leitura:

• max_connections
• max_prepared_transactions
• max_locks_per_transaction
• max_wal_senders
• max_worker_processes

Você pode executar a seguinte consulta tanto no cálculo primário de leitura-gravação quanto no cálculo de réplica de leitura, utilizando o editor SQL do Lakebase ou um cliente SQL como psql.

SELECT name, setting
FROM pg_settings
WHERE name IN (
  'max_connections',
  'max_prepared_transactions',
  'max_locks_per_transaction',
  'max_wal_senders',
  'max_worker_processes'
);

Compare os resultados de ambos os cálculos para identificar as configurações desalinhadas.

Reiniciar computações de réplica de leitura

Se as configurações não estiverem alinhadas, reinicie os cálculos de réplica de leitura para atualizar automaticamente suas configurações. Navegue até a guia Computações da ramificação, localize a réplica de leitura e clique em Editar e, depois, em Reiniciar.

Recursos adicionais

• Visão geral das réplicas de leitura
• Gerenciar cálculos
• Conectar-se ao banco de dados