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:

• Computação com escalabilidade automática: de 0,5 CU a 64 CU (0,5 e, depois, incrementos inteiros: 1, 2, 3... 64)
• Instâncias de computação maiores de tamanho fixo: de 65 CU a 112 CU

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ções para instâncias de computação com escalabilidade automática: Quando a escalabilidade automática está ativada, o número máximo de ligações é determinado pelo valor mais baixo entre o número máximo de CU e 8× o número mínimo de CU. Por exemplo, se configurar o dimensionamento automático entre 2 e 8 CU, o limite de ligações é 1 795 (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 escalonamento automático: O escalonamento automático é suportado para instâncias de computação até 64 CU (128 GB). Para cargas de trabalho que exijam mais de 64 CU, estão disponíveis instâncias de computação maiores de tamanho fixo de 80, 96 ou 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 valor mais baixo entre o teu CU máximo e 8× o teu CU mínimo

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, pode configurar o dimensionamento automático entre 8 e 24 CU, ou entre 48 e 64 CU, mas não entre 0,5 e 32 CU (o que corresponderia a um intervalo de 31,5 CU). O controlo deslizante na aplicação Lakebase aplica esta restrição automaticamente. Para cargas de trabalho que exijam mais de 64 CU, utilize instâncias de computação maiores de tamanho fixo, até 112 CU.

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.

Para uma visão geral de como funciona a escala para zero, veja Escala para zero. Para configurar escalar para zero para um cálculo, veja Configurar escalar 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. Vai ao separador Computes da tua agência 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

Configurar escala para zero

Para configurar escala para zero, inclua spec.suspension na máscara de atualização. Defina suspend_timeout_duration (60s–604800s) para definir o timeout da inatividade, ou no_suspension: true para o desativar. Não defina ambas. A configuração no_suspension: false é inválida e devolve um erro. Por defeito, o ramo production tem o dimensionamento para zero ativado com um limite de tempo de 24 horas.

IU

1. Vai ao separador Computes da tua agência na aplicação Lakebase.
2. Clique em Editar para o cálculo, depois ative ou desative a definição de escala para zero. Quando ativado, configure o tempo de inatividade entre 60 segundos e 7 dias.
3. Clique em Salvar.

Python SDK

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Endpoint, EndpointSpec, EndpointType, FieldMask
from google.protobuf.duration_pb2 import Duration

w = WorkspaceClient()
endpoint_name = "projects/my-project/branches/production/endpoints/my-compute"

# Disable scale to zero (compute stays active indefinitely)
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
    no_suspension=True
)
w.postgres.update_endpoint(
    name=endpoint_name,
    endpoint=Endpoint(name=endpoint_name, spec=endpoint_spec),
    update_mask=FieldMask(field_mask=["spec.suspension"])
).wait()

# Enable scale to zero with a 5-minute inactivity timeout (60s–604800s)
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
    suspend_timeout_duration=Duration(seconds=300)
)
w.postgres.update_endpoint(
    name=endpoint_name,
    endpoint=Endpoint(name=endpoint_name, spec=endpoint_spec),
    update_mask=FieldMask(field_mask=["spec.suspension"])
).wait()

SDK de Java

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

WorkspaceClient w = new WorkspaceClient();
String endpointName = "projects/my-project/branches/production/endpoints/my-compute";

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

// Disable scale to zero (compute stays active indefinitely)
EndpointSpec noSuspensionSpec = new EndpointSpec()
    .setNoSuspension(true);
w.postgres().updateEndpoint(
    new UpdateEndpointRequest()
        .setName(endpointName)
        .setEndpoint(new Endpoint().setSpec(noSuspensionSpec))
        .setUpdateMask(updateMask)
);

// Enable scale to zero with a 5-minute inactivity timeout (60s–604800s)
EndpointSpec timeoutSpec = new EndpointSpec()
    .setSuspendTimeoutDuration(
        Duration.newBuilder().setSeconds(300).build()
    );
w.postgres().updateEndpoint(
    new UpdateEndpointRequest()
        .setName(endpointName)
        .setEndpoint(new Endpoint().setSpec(timeoutSpec))
        .setUpdateMask(updateMask)
);

CLI

# Disable scale to zero (compute stays active indefinitely)
databricks postgres update-endpoint \
  projects/my-project/branches/production/endpoints/my-compute \
  spec.suspension \
  --json '{
    "spec": {
      "no_suspension": true
    }
  }'

# Enable scale to zero with a 5-minute inactivity timeout (60s–604800s)
databricks postgres update-endpoint \
  projects/my-project/branches/production/endpoints/my-compute \
  spec.suspension \
  --json '{
    "spec": {
      "suspend_timeout_duration": "300s"
    }
  }'

encaracolar

# Disable scale to zero (compute stays active indefinitely)
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.suspension" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "no_suspension": true
    }
  }' | jq

# Enable scale to zero with a 5-minute inactivity timeout (60s–604800s)
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.suspension" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "suspend_timeout_duration": "300s"
    }
  }' | jq

Desativar ou ativar um cálculo

Desativar um computador suspende-o e bloqueia todas as novas ligações. Ao contrário da redução para zero, uma capacidade de computação desativada não pode ser reativada por uma tentativa de conexão nem a partir da aplicação Lakebase. Para a reativar, use a API.

Python SDK

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

w = WorkspaceClient()
endpoint_name = "projects/my-project/branches/production/endpoints/my-compute"

# Disable a compute (blocks all connections)
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
    disabled=True
)
w.postgres.update_endpoint(
    name=endpoint_name,
    endpoint=Endpoint(name=endpoint_name, spec=endpoint_spec),
    update_mask=FieldMask(field_mask=["spec.disabled"])
).wait()

# Re-enable a compute
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
    disabled=False
)
w.postgres.update_endpoint(
    name=endpoint_name,
    endpoint=Endpoint(name=endpoint_name, spec=endpoint_spec),
    update_mask=FieldMask(field_mask=["spec.disabled"])
).wait()

Para verificar se um cálculo está atualmente desativado, leia o valor do estado do endpoint. Define o valor em spec.disabled, mas lê-o de volta a partir de status.disabled:

endpoint = w.postgres.get_endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute"
)
print(endpoint.status.disabled)  # True = disabled, False or None = enabled

CLI

# Disable a compute (blocks all connections)
databricks postgres update-endpoint \
  projects/my-project/branches/production/endpoints/my-compute \
  spec.disabled \
  --json '{
    "spec": {
      "disabled": true
    }
  }'

# Re-enable a compute
databricks postgres update-endpoint \
  projects/my-project/branches/production/endpoints/my-compute \
  spec.disabled \
  --json '{
    "spec": {
      "disabled": false
    }
  }'

Para verificar se um recurso de computação está atualmente desativado, leia status.disabled no endpoint:

databricks postgres get-endpoint projects/my-project/branches/production/endpoints/my-compute --output json | jq '.status.disabled'

encaracolar

# Disable a compute (blocks all connections)
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.disabled" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "disabled": true
    }
  }' | jq

# Re-enable a compute
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.disabled" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "disabled": false
    }
  }' | jq

Para verificar se um recurso de computação está atualmente desativado, leia status.disabled no endpoint:

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

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. Vai ao separador Computes da tua agência na aplicação Lakebase.
2. Clique no Menu para o cálculo, selecione Reiniciar e confirme a operação.

Recursos adicionais

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