Gerenciar cálculos

Uma instância de computação é um serviço virtualizado que executa Postgres para seus projetos do Lakebase. Cada ramificação tem uma computação primária (leitura/gravação). Uma computação é necessária para se conectar a uma ramificação e acessar seus dados. Para obter uma visão geral de como os cálculos e pontos de extremidade se relacionam, consulte Computação e pontos de extremidade.

Noções básicas sobre 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, gerenciar conexões e lidar com operações de banco de dados. Cada projeto tem uma computação de leitura e gravação primária para sua ramificação padrão.

Para se conectar a um banco de dados em um branch, você deve usar uma computação associada a esse branch. Cálculos maiores consomem mais horas de computação no mesmo período de tempo ativo do que cálculos menores.

Identificadores de computação

Cada computação tem três identificadores, acessíveis no menu Obter ID na guia Computação:

O nome do host na sua string de conexão usa o UID, não o nome da máquina.

Dimensionamento de computação

Tamanhos de computação disponíveis

O Lakebase Postgres dá suporte aos seguintes tamanhos de computação:

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

O que há em uma Unidade de Computação?

Cada Unidade de Computação (CU) destina cerca de 2 GB de RAM para a instância do banco de dados, juntamente com todos os recursos de CPU e SSD locais associados. Escalar verticalmente aumenta esses recursos linearmente. O Postgres distribui a memória alocada entre vários componentes:

• Caches de banco de dados
• Memória do trabalho
• Outros processos com requisitos de memória fixos

O desempenho varia de acordo com o tamanho dos dados e a complexidade da consulta. Antes de dimensionar, teste e otimize as consultas. O armazenamento é dimensionado automaticamente.

Especificações de computação

Limites de conexão para instâncias de computação com escalonamento automático: Quando o escalonamento automático está habilitado, o número máximo de conexões é determinado pelo menor valor entre sua CU máxima e 8× sua CU mínima. Por exemplo, se você configurar o dimensionamento automático entre 2 e 8 CUs, seu limite de conexões será 1.795 (o limite para 8 CUs).

Limites de conexão de réplicas de leitura: os limites de conexão de computação das réplicas de leitura são sincronizados com as configurações primárias de computação de leitura/gravação. Consulte Gerenciar réplicas de leitura para obter detalhes.

Diretrizes de dimensionamento

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

Estratégia de dimensionamento ideal

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

• Conjunto de dados completo na memória: escolha um tamanho de computação que possa manter todo o conjunto de dados na memória para obter o melhor desempenho
• Conjunto de trabalho na memória: para grandes conjuntos de dados, verifique se os dados acessados com frequência se encaixam na memória
• Limites de conexão: selecione um tamanho que dê suporte às suas conexões máximas simultâneas previstas

Dimensionamento Automático

O Lakebase dá suporte a configurações de computação de tamanho fixo e dimensionamento automático. O dimensionamento automático ajusta dinamicamente os recursos de computação com base na demanda de carga de trabalho, otimizando o desempenho e o custo.

Limite de dimensionamento automático: Há suporte para dimensionamento automático para capacidades computacionais de até 64 CU (128 GB). Para cargas de trabalho que exigem mais de 64 CU, estão disponíveis instâncias de computação maiores, de tamanho fixo, com 80, 96 ou 112 CU.

Configurando o dimensionamento automático

Para habilitar ou ajustar o dimensionamento automático para uma computação, edite a computação e use o controle deslizante para definir tamanhos mínimos e máximos de computação.

Para obter uma visão geral de como o dimensionamento automático funciona, consulte Dimensionamento automático.

Considerações de dimensionamento automático

Para obter um desempenho ideal do dimensionamento automático:

• Defina seu tamanho mínimo de computação grande o suficiente para armazenar em cache seu conjunto de trabalho na memória
• Considere que um desempenho ruim pode ocorrer até que a computação seja ampliada e armazene seus dados em cache
• Seus limites de conexão são baseados no menor valor entre sua CU máxima e 8× sua CU mínima

Restrições de intervalo de dimensionamento automático: a diferença entre seus tamanhos máximos e mínimos de unidades de computação não pode exceder 16 CUs (ou seja, max - min ≤ 16 CU). Por exemplo, você pode configurar o dimensionamento automático de 8 a 24 CU ou de 48 a 64 CU, mas não de 0,5 a 32 CU (o que resultaria em um intervalo de 31,5 CU). O controle deslizante no Aplicativo Lakebase impõe essa restrição automaticamente. Para cargas de trabalho que exigem mais de 64 CU, use instâncias de computação maiores de tamanho fixo, de até 112 CU.

Reduzir para zero

O recurso de escala para zero do Lakebase transiciona automaticamente uma computação para um estado ocioso após um período de inatividade, reduzindo os custos para bancos de dados que não estão continuamente ativos.

Para obter uma visão geral de como a escala para zero funciona, consulte Escala a zero. Para configurar a escala como zero para uma computação, consulte Configurar a escala como zero.

Criar e gerenciar cálculos

Exibir cálculos

Exibir na interface do usuário

Para visualizar os cômputos de um branch, navegue até a página Branches do projeto no Lakebase App e selecione um branch para visualizar a aba Cômputos.

A guia Computes exibe informações sobre todos os recursos de computação associados ao branch. As informações mostradas na guia Computação são descritas na tabela a seguir.

Para cada computação, você pode:

• Clique no Conectar para abrir uma caixa de diálogo de conexão com os detalhes de conexão para a ramificação associada ao sistema de computação. A caixa de diálogo inclui um alternador de Pooling de conexões para funções de senha nativas do Postgres. Consulte Conectar-se ao banco de dados e usar o pool de conexões.
• Clique em Editar para modificar o tamanho da computação (intervalo de dimensionamento fixo ou automático) e definir configurações de escala a zero. Consulte Editar uma computação.
• Clique no ícone de menu para acessar opções adicionais:
  • Monitorar a atividade: exibir a atividade de computação e as métricas de desempenho. Consulte Monitorar seu banco de dados.
  • Reiniciar a computação: reinicie a computação para resolver problemas de conexão ou aplicar alterações de configuração. Consulte Reiniciar uma computação.

Para adicionar uma computação de réplica de leitura à ramificação, clique em Adicionar Réplica de Leitura. As réplicas de leitura são computações somente leitura que permitem o dimensionamento horizontal, permitindo que você descarregue a carga de trabalho de leitura de sua computação primária. Consulte Réplicas de leitura e Gerenciar réplicas de leitura.

Obter um cálculo programaticamente

Para obter detalhes sobre uma computação específica usando a API do Postgres:

SDK do Python

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, acesse o host por meio endpoint.status.hosts.host (não endpoint.status.host).

SDK do 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

curl

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

Listar computações programaticamente

Para listar todos os cálculos e réplicas de leitura para uma ramificação usando a API do Postgres:

SDK do Python

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, acesse o host por meio endpoint.status.hosts.host (não endpoint.status.host).

SDK do 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

curl

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

Editar uma computação

Você pode editar uma instância de computação para alterar seu tamanho, configuração de dimensionamento automático ou ajuste de escala para zero. Os nomes de computação são somente leitura e não podem ser renomeados.

Para editar uma computação:

interface do usuário

1. Acesse a guia Computações da sua ramificação no Aplicativo Lakebase.
2. Clique em Editar para a computação, ajuste suas configurações 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 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 na especificação e 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 do 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 na especificação e 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
    }
  }'

curl

# 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

Definir a escala para zero

Para configurar a escala como zero, inclua spec.suspension na máscara de atualização. Defina suspend_timeout_duration (60s–604800s) para definir o tempo limite de inatividade ou no_suspension: true desabilitá-lo. Não defina ambas. A configuração no_suspension: false é inválida e retorna um erro. Por padrão, o ramo production está com o escalonamento para zero habilitado, com tempo limite de 24 horas.

interface do usuário

1. Acesse a guia Computações da sua ramificação no Aplicativo Lakebase.
2. Clique em Editar para a computação e, em seguida, habilite ou desabilite a configuração de escala para zero. Quando habilitado, configure o tempo limite de inatividade entre 60 segundos e 7 dias.
3. Clique em Salvar.

SDK do Python

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 do 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"
    }
  }'

curl

# 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

Desabilitar ou habilitar uma computação

Desabilitar uma computação o suspende e bloqueia todas as novas conexões. Ao contrário do escalonamento para zero, um recurso de computação desabilitado não pode ser reativado por uma tentativa de conexão nem pelo app do Lakebase. Para habilitá-la novamente, use a API.

SDK do Python

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 recurso de computação está desabilitado no momento, leia o valor no status do endpoint. Você define o valor em spec.disabled, mas o lê 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'

curl

# 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

Reinicie uma computação para aplicar atualizações, resolver problemas de desempenho ou selecionar alterações de configuração.

Para reiniciar uma computação:

1. Acesse a guia Computações da sua ramificação no Aplicativo Lakebase.
2. Clique no menu para a computação, selecione Reiniciar e confirme a operação.

Recursos adicionais

• Painel de métricas
• Escala automática
• Escalonar para zero
• Réplicas de leitura