Gerir computações

Um compute é um serviço virtualizado que executa o Postgres para os seus projetos Lakebase. Cada filial tem uma unidade de computação primária (leitura-escrita). É necessário um computador para se ligar a uma sucursal e aceder aos seus dados. Para uma visão geral de como os cálculos e os endpoints se relacionam, veja Computes and endpoints.

Compreensão dos cálculos

Visão geral da computação

Os recursos de computação fornecem o poder de processamento e a memória necessários para executar consultas, gerir ligações e gerir operações de base de dados. Cada projeto tem um cálculo primário de leitura-escrita para o seu ramo predefinido.

Para se ligar a uma base de dados num ramo, deve usar um cálculo associado a esse ramo. Cálculos maiores consomem mais horas de cálculo no mesmo período de tempo ativo do que cálculos mais pequenos.

Identificadores de computação

Cada cálculo tem três identificadores, acessíveis a partir do menu Obter ID no separador Computes:

O nome de host na tua cadeia de ligação usa o UID, não o nome da computação.

Dimensionamento computacional

Tamanhos de computação disponíveis

O Lakebase Postgres suporta os seguintes tamanhos de cálculo:

• Autoscale calcula: 0,5 UC a 32 UC (0,5, depois incrementos inteiros: 1 UC, 2 UC, 3 UC... 16 UC, depois 24 UC, 28 UC, 32 UC)
• Unidades de Cálculo de tamanho fixo maiores: 36 CU a 112 CU (36, 40, 44, 48, 52, 56, 60, 64, 72, 80, 88, 96, 104, 112)

O que há numa unidade de computação?

Cada Unidade de Computação () aloca aproximadamente 2 GB de RAM à instância da base de dados, juntamente com todos os recursos associados da CPU e SSD local. A ampliação aumenta esses recursos linearmente. O Postgres distribui a memória alocada em vários componentes:

• Caches de banco de dados
• Memória do trabalhador
• Outros processos com requisitos de memória fixa

O desempenho varia com base no tamanho dos dados e na complexidade da consulta. Antes de escalar, teste e otimize as consultas. O armazenamento é dimensionado automaticamente.

Especificações de computação

Limites de ligação para computação de autoescalonamento: Quando o autoescalonamento está ativado, o número máximo de ligações é determinado pelo tamanho máximo de unidade de computação (CU) na sua faixa de autoescalonamento. Por exemplo, se configurarem o autoscaling entre 2 CU até 8 CU, o teu limite de ligação é 1.678 (o limite para 8 CU).

Limites de ligação de réplicas de leitura: Limites de conexões de computação das réplicas de leitura são sincronizados com as suas definições de computação de leitura e escrita principais. Consulte a seção Gerir réplicas de leitura para mais detalhes.

Orientação de dimensionamento

Ao selecionar um tamanho de computação, considere estes fatores:

Estratégia de dimensionamento ótima

Selecione um tamanho de computação com base nos seus requisitos de dados:

• Conjunto de dados completo na memória: Escolha um tamanho de computação que consiga armazenar todo o seu conjunto de dados em memória para melhor desempenho
• Conjunto de trabalho na memória: Para grandes conjuntos de dados, assegure que os seus dados frequentemente acedidos cabem na memória
• Limites de ligação: Selecione um tamanho que suporte as suas ligações máximas concorrentes previstas

Autoescalonamento

O Lakebase suporta tanto configurações de computação de tamanho fixo como de autoescalonamento. O autoscaling ajusta dinamicamente os recursos computacionais com base na procura da carga de trabalho, otimizando tanto o desempenho como o custo.

Limite de autoescalonamento: O autoescalonamento é suportado para unidades de computação até 32 CUs. Para cargas de trabalho que requerem mais de 32 CU, estão disponíveis unidades de computação de tamanho fixo maiores, de 36 CU a 112 CU.

Configuração do autoescalonamento

Para ativar ou ajustar o autoscaling para um cálculo, edite o cálculo e use o slider para definir os tamanhos mínimos e máximos de computação.

Para uma visão geral de como funciona o autoscaling, veja Autoscaling.

Considerações sobre o autoescalonamento

Para um desempenho ótimo de dimensionamento automático:

• Defina o seu tamanho mínimo de computação suficientemente grande para armazenar em cache o seu conjunto de trabalho na memória
• Considere que o baixo desempenho pode ocorrer até que o cálculo escale e armazene os seus dados em cache
• Os teus limites de ligação baseiam-se no tamanho máximo de computação na tua faixa de autoescalonamento

Restrições de alcance de autoescalonamento: A diferença entre os seus tamanhos máximo e mínimo de computação não pode exceder 16 CU (isto é, max - min ≤ 16 CU). Por exemplo, podes configurar o autoscaling de 8 CU para 24 CU, ou de 16 CU para 32 CU, mas não de 0,5 CU para 32 CU (que seria um intervalo de 31,5 CU). Esta restrição garante um comportamento de escalabilidade gerível, mantendo ao mesmo tempo flexibilidade. O slider na aplicação Lakebase aplica automaticamente esta restrição quando configura o seu intervalo de autoescalonamento. Para cargas de trabalho que requerem mais de 32 CUs, utilize unidades de computação de tamanho fixo maiores.

Reduzir para zero

A funcionalidade de escala para zero do Lakebase faz automaticamente a transição de um cálculo para um estado de inatividade após um período de inatividade, reduzindo custos para bases de dados que não estão continuamente ativas.

Configurar escala para zero

Para ativar ou ajustar a escala para zero num cálculo, edite o cálculo e alterne a definição de escala para zero. Quando ativado, pode configurar o tempo limite de inatividade.

Para uma visão geral de como funciona a escala para zero, veja Escala para zero.

Criar e gerir computações

Visualização computa

Visualização na interface de utilizador

Para visualizar os cálculos de um ramo, navegue até à página de Ramos do seu projeto na aplicação Lakebase e selecione um ramo para visualizar o separador Computes .

O separador Computes apresenta informações sobre todos os cálculos associados ao ramo. A informação apresentada no separador Computes está descrita na tabela seguinte.

Para cada cálculo, pode:

• Clique em Ligar para abrir um diálogo de ligação com detalhes de ligação para o ramo associado ao cálculo. O diálogo inclui um interruptor de pooling de ligações para funções nativas de palavra-passe do Postgres. Veja Ligar à sua base de dados e Usar gestão de conexões.
• Clique em Editar para modificar o tamanho do cálculo (intervalo fixo ou de autoescala) e configurar definições de escala para zero. Ver Editar um cálculo.
• Clique no ícone do menu para aceder a opções adicionais:
  • Monitorizar atividade: Veja a atividade de cálculo e métricas de desempenho. Veja Monitorizar a sua base de dados.
  • Reiniciar o cálculo: Reiniciar o cálculo para resolver problemas de ligação ou aplicar alterações de configuração. Veja Reiniciar um cálculo.

Para adicionar um cálculo de réplica de leitura ao ramo, clique em Adicionar Réplica de Leitura. As réplicas de leitura são instâncias apenas de leitura que permitem escalonamento horizontal, permitindo-lhe descarregar a carga de trabalho de leitura da sua computação principal. Ver Réplicas de leitura e Gerir réplicas de leitura.

Faz uma computação programática

Para obter detalhes sobre um cálculo específico usando a API Postgres:

Python SDK

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# Get endpoint details
endpoint = w.postgres.get_endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute"
)

print(f"Endpoint: {endpoint.name}")
print(f"Type: {endpoint.status.endpoint_type}")
print(f"State: {endpoint.status.current_state}")
print(f"Host: {endpoint.status.hosts.host}")
print(f"Min CU: {endpoint.status.autoscaling_limit_min_cu}")
print(f"Max CU: {endpoint.status.autoscaling_limit_max_cu}")

No SDK, acede ao host via endpoint.status.hosts.host (não endpoint.status.host).

SDK de Java

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

WorkspaceClient w = new WorkspaceClient();

// Get endpoint details
Endpoint endpoint = w.postgres().getEndpoint(
    "projects/my-project/branches/production/endpoints/my-compute"
);

System.out.println("Endpoint: " + endpoint.getName());
System.out.println("Type: " + endpoint.getStatus().getEndpointType());
System.out.println("State: " + endpoint.getStatus().getCurrentState());
System.out.println("Host: " + endpoint.getStatus().getHosts().getHost());
System.out.println("Min CU: " + endpoint.getStatus().getAutoscalingLimitMinCu());
System.out.println("Max CU: " + endpoint.getStatus().getAutoscalingLimitMaxCu());

CLI

# Get endpoint details
databricks postgres get-endpoint projects/my-project/branches/production/endpoints/my-compute --output json | jq

encaracolar

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

Lista calcula programaticamente

Para listar todos os cálculos e réplicas de leitura para um branch usando a API Postgres:

Python SDK

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# List all endpoints for a branch
endpoints = list(w.postgres.list_endpoints(
    parent="projects/my-project/branches/production"
))

for endpoint in endpoints:
    print(f"Endpoint: {endpoint.name}")
    print(f"  Type: {endpoint.status.endpoint_type}")
    print(f"  State: {endpoint.status.current_state}")
    print(f"  Host: {endpoint.status.hosts.host}")
    print(f"  CU Range: {endpoint.status.autoscaling_limit_min_cu}-{endpoint.status.autoscaling_limit_max_cu}")
    print()

No SDK, acede ao host via endpoint.status.hosts.host (não endpoint.status.host).

SDK de Java

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

WorkspaceClient w = new WorkspaceClient();

// List all endpoints for a branch
for (Endpoint endpoint : w.postgres().listEndpoints("projects/my-project/branches/production")) {
    System.out.println("Endpoint: " + endpoint.getName());
    System.out.println("  Type: " + endpoint.getStatus().getEndpointType());
    System.out.println("  State: " + endpoint.getStatus().getCurrentState());
    System.out.println("  Host: " + endpoint.getStatus().getHosts().getHost());
    System.out.println("  CU Range: " + endpoint.getStatus().getAutoscalingLimitMinCu() +
        "-" + endpoint.getStatus().getAutoscalingLimitMaxCu());
    System.out.println();
}

CLI

# List endpoints for a branch
databricks postgres list-endpoints projects/my-project/branches/production --output json | jq

encaracolar

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

Editar um cálculo

Podes editar um cálculo para alterar o seu tamanho, configuração de autoescalabilidade ou escalar para zero. Os nomes de computação são apenas de leitura e não podem ser renomeados.

Para editar um cálculo:

IU

1. Vá para a aba Computes da sua filial na aplicação Lakebase.
2. Clica em Editar para o cálculo, ajusta as definições e clica em Guardar.

Python SDK

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

w = WorkspaceClient()

# Update a single field (max CU)
endpoint_spec = EndpointSpec(endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE, autoscaling_limit_max_cu=6.0)
endpoint = Endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute",
    spec=endpoint_spec
)

result = w.postgres.update_endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute",
    endpoint=endpoint,
    update_mask=FieldMask(field_mask=["spec.autoscaling_limit_max_cu"])
).wait()

print(f"Updated max CU: {result.status.autoscaling_limit_max_cu}")

Para atualizar vários campos, inclua-os tanto na especificação como na máscara de atualização:

# Update multiple fields (min and max CU)
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
    autoscaling_limit_min_cu=1.0,
    autoscaling_limit_max_cu=8.0
)
endpoint = Endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute",
    spec=endpoint_spec
)

result = w.postgres.update_endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute",
    endpoint=endpoint,
    update_mask=FieldMask(field_mask=[
        "spec.autoscaling_limit_min_cu",
        "spec.autoscaling_limit_max_cu"
    ])
).wait()

print(f"Updated min CU: {result.status.autoscaling_limit_min_cu}")
print(f"Updated max CU: {result.status.autoscaling_limit_max_cu}")

SDK de Java

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

WorkspaceClient w = new WorkspaceClient();

// Update a single field (max CU)
EndpointSpec endpointSpec = new EndpointSpec()
    .setAutoscalingLimitMaxCu(6.0);

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

w.postgres().updateEndpoint(
    new UpdateEndpointRequest()
        .setName("projects/my-project/branches/production/endpoints/my-compute")
        .setEndpoint(new Endpoint().setSpec(endpointSpec))
        .setUpdateMask(updateMask)
);

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

Para atualizar vários campos, inclua-os tanto na especificação como na máscara de atualização:

// Update multiple fields (min and max CU)
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("projects/my-project/branches/production/endpoints/my-compute")
        .setEndpoint(new Endpoint().setSpec(endpointSpec))
        .setUpdateMask(updateMask)
);

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

CLI

# Update a single field (max CU)
databricks postgres update-endpoint projects/my-project/branches/production/endpoints/my-compute spec.autoscaling_limit_max_cu \
  --json '{
    "spec": {
      "autoscaling_limit_max_cu": 6.0
    }
  }'

# Update multiple fields (min and max CU)
databricks postgres update-endpoint projects/my-project/branches/production/endpoints/my-compute "spec.autoscaling_limit_min_cu,spec.autoscaling_limit_max_cu" \
  --json '{
    "spec": {
      "autoscaling_limit_min_cu": 1.0,
      "autoscaling_limit_max_cu": 8.0
    }
  }'

encaracolar

# Update a single field (max CU)
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.autoscaling_limit_max_cu" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "autoscaling_limit_max_cu": 6.0
    }
  }' | jq

# Update multiple fields (min and max CU)
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?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-compute",
    "spec": {
      "autoscaling_limit_min_cu": 1.0,
      "autoscaling_limit_max_cu": 8.0
    }
  }' | jq

Reiniciar uma computação

Reiniciar um cálculo para aplicar atualizações, resolver problemas de desempenho ou detetar alterações de configuração.

Para reiniciar um cálculo:

1. Vá para a aba Computes da sua filial na aplicação Lakebase.
2. Clique no Menu para o cálculo, selecione Reiniciar e confirme a operação.

Informações adicionais

• Painel de métricas
• Dimensionamento automático
• Escala até zero
• Ler réplicas