gerenciar computação
O dimensionamento automático do Lakebase está disponível nas seguintes regiões: us-east-1, us-east-2, eu-central-1, eu-west-1, eu-west-2, ap-south-1, ap-southeast-1, ap-southeast-2.
O Lakebase autoscale é a versão mais recente do Lakebase com recursos como autoscale compute, escala-to-zero, branching e instant restore. Para comparação de recursos com o provisionamento do Lakebase, veja escolhendo entre versões.
compute é um serviço virtualizado que executa Postgres para seus projetos Lakebase. Cada ramificação possui um compute primário (de leitura e escrita). É necessário um compute para conectar-se a uma filial e acessar seus dados.
Entendendo a computação
visão geral de 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 possui um compute principal de leitura e gravação para seu branch default .
Para se conectar a um banco de dados em uma filial, você deve usar um compute associado a essa filial. Computadores maiores consomem mais horas compute durante o mesmo período de atividade do que computadores menores.
dimensionamento de cálculo
Tamanhos compute disponíveis
O Lakebase Postgres suporta os seguintes tamanhos compute :
- autoscale compute : 0,5 CU a 32 CU (0,5, depois incrementos inteiros: 1, 2, 3... 16, depois 24, 28, 32)
- Computação de tamanho fixo maior : 36 CU a 112 CU (36, 40, 44, 48, 52, 56, 60, 64, 72, 80, 88, 96, 104, 112)
O que contém uma unidade de computação?
Cada Unidade de Computação (CU) aloca aproximadamente 2 GB de RAM para a instância do banco de dados, juntamente com todos os recursos de CPU e SSD locais associados. A ampliação da escala aumenta esses recursos de forma linear. O Postgres distribui a memória alocada entre vários componentes:
- Caches de banco de dados
- memória do trabalhador
- 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 expandir, teste e otimize as consultas. O armazenamento escala automaticamente.
Provisionamento Lakebase vs escalonamento automático : No provisionamento Lakebase, cada unidade de computação alocou aproximadamente 16 GB de RAM. No Lakebase com escalonamento automático, cada Unidade de Computação (CU) aloca 2 GB de RAM. Essa mudança proporciona opções de dimensionamento mais detalhadas e maior controle de custos.
especificações de cálculo
Unidades de cálculo | BATER | Conexões máximas |
|---|---|---|
0,5 CU | ~1 GB | 104 |
1 CU | ~2 GB | 209 |
2 CU | ~4 GB | 419 |
3 CU | ~6 GB | 629 |
4 CU | ~8 GB | 839 |
5 CU | ~10 GB | 1049 |
6 CU | ~12 GB | 1258 |
7 CU | ~14 GB | 1468 |
8 CU | ~16 GB | 1678 |
9 CU | ~18 GB | 1888 |
10 CU | ~20 GB | 2098 |
12 CU | ~24 GB | 2517 |
14 CU | ~28 GB | 2937 |
16 CU | ~32 GB | 3357 |
24 CU | ~48 GB | 4000 |
28 CU | ~56 GB | 4000 |
32 CU | ~64 GB | 4000 |
36 CU | ~72 GB | 4000 |
40 CU | ~80 GB | 4000 |
44 CU | ~88 GB | 4000 |
48 CU | ~96 GB | 4000 |
52 CU | ~104 GB | 4000 |
56 CU | ~112 GB | 4000 |
60 CU | ~120 GB | 4000 |
64 CU | ~128 GB | 4000 |
72 CU | ~144 GB | 4000 |
80 CU | ~160 GB | 4000 |
88 CU | ~176 GB | 4000 |
96 CU | ~192 GB | 4000 |
104 CU | ~208 GB | 4000 |
112 CU | ~224 GB | 4000 |
Limites de conexão para computação com dimensionamento automático : Quando o dimensionamento automático está ativado, o número máximo de conexões é determinado pelo tamanho máximo da Unidade de Computação (CU) no seu intervalo de dimensionamento automático. Por exemplo, se você configurar o dimensionamento automático entre 2 e 8 CUs, seu limite de conexão será de 1.678 (o limite para 8 CUs).
Limites de conexão da réplica de leitura : Os limites de conexão compute da réplica de leitura são sincronizados com suas configurações compute primária de leitura e gravação. Consulte o gerente para obter mais detalhes sobre as réplicas .
Algumas conexões são reservadas para uso administrativo e do sistema. Por esse motivo, SHOW max_connections pode apresentar um valor maior do que o número máximo de conexões exibido na tabela acima ou no painel Editar compute do aplicativo Lakebase. Os valores na tabela e na gaveta refletem o número real de conexões disponíveis para uso direto, enquanto SHOW max_connections inclui conexões reservadas.
Guia de tamanhos
Ao selecionar o tamanho compute , considere os seguintes fatores:
Fator | Recomendação |
|---|---|
Complexidade da consulta | Consultas analíticas complexas se beneficiam de capacidades compute maiores. |
conexões concorrentes | Mais conexões exigem mais CPU e memória. |
Volume de dados | Conjuntos de dados maiores podem exigir mais memória para um desempenho ideal. |
Tempo de resposta | Aplicações críticas podem exigir maior capacidade computacional para um desempenho consistente. |
Estratégia de dimensionamento ideal
Selecione um tamanho compute com base nos seus requisitos de dados:
- dataset completo na memória : Escolha um tamanho compute que possa armazenar todo o seu dataset na memória para obter o melhor desempenho.
- Conjunto de trabalho na memória : Para conjuntos de dados grandes, certifique-se de que os dados acessados com frequência caibam na memória.
- Limites de conexão : Selecione um tamanho que suporte o número máximo de conexões simultâneas previsto.
escala automática
O Lakebase suporta configurações compute de tamanho fixo e de escalonamento automático. O recurso de dimensionamento automático ajusta dinamicamente os recursos compute com base na demanda da carga de trabalho, otimizando tanto o desempenho quanto o custo.
Tipo de configuração | Descrição |
|---|---|
Tamanho fixo (0,5-32 CU) | Selecione um tamanho compute fixo que não aumente com a demanda de carga de trabalho. Disponível para computação de 0,5 CU a 32 CUs. |
autodimensionamento (0,5-32 CU) | Use um controle deslizante para especificar os tamanhos mínimo e máximo compute . A escala do Lakebase sobe e desce dentro desses limites com base na carga atual. Disponível para computação de até 32 CUs. |
Computação de tamanho fixo maior (36-112 CU) | Selecione uma compute de tamanho fixo maior, de 36 CU a 112 CU. Esses servidores de computação de maior capacidade estão disponíveis apenas em tamanhos fixos e não suportam dimensionamento automático. |
Limite de dimensionamento automático: o dimensionamento automático é compatível com computação de até 32 CUs. Para cargas de trabalho que exigem mais de 32 CUs, estão disponíveis capacidades computacionais fixas maiores, de 36 a 112 CUs.
Configurando o dimensionamento automático
Para ativar ou ajustar a escala automática de um compute, edite o compute e use o controle deslizante para definir os tamanhos mínimo e máximo compute .

Para uma visão geral de como funciona o dimensionamento automático, consulte dimensionamento automático.
Considerações sobre escala automática
Para desempenho ideal de escala automática:
- Defina o tamanho mínimo compute suficientemente grande para armazenar em cache o conjunto de trabalho na memória.
- Considere que um desempenho ruim pode ocorrer até que o compute seja ampliado e seus dados sejam armazenados em cache.
- Seus limites de conexão são baseados no tamanho máximo compute em seu intervalo de dimensionamento automático.
Restrições de intervalo de autodimensionamento : A diferença entre seus tamanhos compute máximo e mínimo não pode exceder 8 CU (ou seja, max - min ≤ 8 CU). Por exemplo, você pode configurar o dimensionamento automático de 8 a 16 CU ou de 16 a 24 CU, mas não de 0,5 a 32 CU (que seria um intervalo de 31,5 CU). Essa restrição garante um comportamento de escalabilidade gerenciável, ao mesmo tempo que proporciona flexibilidade. O controle deslizante no aplicativo Lakebase aplica essa restrição automaticamente quando você configura o intervalo de dimensionamento automático. Para cargas de trabalho que exigem mais de 32 CUs, utilize computação de tamanho fixo maior.
escalar para zero
O recurso "escala-to-zero" do Lakebase automaticamente transforma um compute em um estado "parado" após um período de inatividade, reduzindo os custos para bancos de dados que não estão continuamente ativos.
Configuração | Descrição |
|---|---|
escalar para zero ativado | O sistema de computação suspende automaticamente a atividade após um período de inatividade para reduzir custos. |
escalar para zero desativado | Mantenha um compute "sempre ativo" que elimine a latência startup |
Configurando a escala para zero
Para ativar ou ajustar a escala para zero em um compute, edite o compute e alterne a configuração de escala para zero. Quando ativada, você pode configurar o tempo limite de inatividade.

Ao criar um projeto, o branch production é criado com um compute que tem o escala-to-zero desativado por default, o que significa que o compute permanece ativo o tempo todo. Você pode habilitar a escalação para zero para este compute , se necessário.
Para uma visão geral de como funciona o escala to zero, consulte escala to zero.
Criar e gerenciar computadores
visualizar computar
Visualizar na interface do usuário
Para view os dados de computação de uma ramificação, acesse a página "Ramos" do seu projeto no aplicativo Lakebase e selecione uma ramificação para view a tab de computação correspondente .

A tab "Compute" exibe informações sobre todos os cálculos associados à ramificação. As informações exibidas na tab "Calcular" estão resumidas na tabela a seguir.
Detalhe | Descrição |
|---|---|
Tipo de Compute | O tipo compute é Primário (leitura e gravação) ou Réplica de Leitura (somente leitura). Uma ramificação pode ter um único servidor primário (leitura e gravação) e várias réplicas de leitura (somente leitura). |
Status | Estado atual: Ativo ou Suspenso (quando o compute foi suspenso devido à redução da capacidade para zero). Mostra a data e a hora em que o compute foi suspenso. |
ID do ponto de extremidade | O ID endpoint compute , que começa com o prefixo |
Tamanho | O tamanho compute em unidadescompute (CU). Exibe um único valor de CU (por exemplo, 8 CU) para computação de tamanho fixo. Exibe um intervalo (por exemplo, 8-16) para computação com dimensionamento automático ativado. |
Última atividade | A data e a hora em que o compute esteve ativo pela última vez. |
Para cada compute, você pode:
- Clique em Conectar para abrir uma caixa de diálogo de conexão com os detalhes da conexão para a ramificação associada ao compute. Consulte Conectar-se ao seu banco de dados.
- Clique em Editar para modificar o tamanho compute (intervalo fixo ou de escala automática) e configurar as definições de escala para zero. Consulte Editar um compute.
- Clique no ícone de menu para acessar opções adicionais:
- Monitorar atividade : visualizar atividades compute e métricas de desempenho. Consulte Monitorar seu banco de dados.
- Reiniciar compute : Reinicie o compute para resolver problemas de conexão ou aplicar alterações de configuração. Consulte Reiniciar um compute.
- Excluir compute : Remove permanentemente a compute do branch. Consulte Excluir um compute.
Para adicionar uma compute de leitura ao branch, clique em Adicionar Réplica de Leitura . As réplicas de leitura são computação somente leitura que permitem o escalonamento horizontal, possibilitando o descarregamento da carga de trabalho de leitura da compute primária. Veja Réplicas de leitura e gerenciar réplicas de leitura.
Obtenha um programa compute
Para obter detalhes sobre um compute específico usando a API do Postgres:
- Python SDK
- Java SDK
- CLI
- curl
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 através de endpoint.status.hosts.host (não endpoint.status.host).
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());
# Get endpoint details
databricks postgres get-endpoint projects/my-project/branches/production/endpoints/my-compute --output json | jq
curl "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute" \
-H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq
Listar computacionalmente
Para listar todas as réplicas de computação e leitura de uma ramificação usando a API do Postgres:
- Python SDK
- Java SDK
- CLI
- curl
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 através de endpoint.status.hosts.host (não endpoint.status.host).
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();
}
# List endpoints for a branch
databricks postgres list-endpoints projects/my-project/branches/production --output json | jq
curl "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints" \
-H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq
Configurações típicas de ramificação:
- 1 endpoint: compute primária somente para leitura e gravação
- 2+ pontos de extremidade: compute primária mais uma ou mais réplicas de leitura
Criar um compute
Você pode criar um compute primário de leitura e gravação para uma ramificação que não possua um. Por default os branches criados na interface do usuário do Lakebase são criados automaticamente com compute de leitura e gravação. Você só precisa criar um compute manualmente se tiver excluído um compute ou criado uma ramificação por outro método.
Cada ramificação pode ter apenas uma compute de leitura e escrita. Se sua ramificação já possui um compute de leitura e gravação, você verá uma opção para adicionar uma réplica de leitura. As réplicas de leitura são computação somente leitura que permitem escalonamento horizontal e outros casos de uso. Saiba mais: Leia as réplicas | Gerenciar leia as réplicas
Para criar um compute:
- UI
- Python SDK
- Java SDK
- CLI
- curl
- Acesse tab de computação da sua filial no aplicativo Lakebase.
- Clique em Adicionar um compute , configure as suas definições compute e clique em Adicionar .
from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Endpoint, EndpointSpec, EndpointType
w = WorkspaceClient()
# Create compute endpoint (READ_WRITE)
endpoint_spec = EndpointSpec(
endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
autoscaling_limit_max_cu=4.0
)
endpoint = Endpoint(spec=endpoint_spec)
result = w.postgres.create_endpoint(
parent="projects/my-project/branches/production",
endpoint=endpoint,
endpoint_id="my-compute"
).wait()
print(f"Endpoint created: {result.name}")
print(f"Host: {result.status.hosts.host}")
import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;
WorkspaceClient w = new WorkspaceClient();
// Create compute endpoint (READ_WRITE)
EndpointSpec endpointSpec = new EndpointSpec()
.setEndpointType(EndpointType.ENDPOINT_TYPE_READ_WRITE)
.setAutoscalingLimitMaxCu(4.0);
Endpoint endpoint = new Endpoint().setSpec(endpointSpec);
Endpoint result = w.postgres().createEndpoint(
new CreateEndpointRequest()
.setParent("projects/my-project/branches/production")
.setEndpoint(endpoint)
.setEndpointId("my-compute")
).waitForCompletion();
System.out.println("Endpoint created: " + result.getName());
System.out.println("Host: " + result.getStatus().getHosts().getHost());
# Create a read-write compute for a branch
databricks postgres create-endpoint projects/my-project/branches/production my-compute \
--json '{
"spec": {
"endpoint_type": "ENDPOINT_TYPE_READ_WRITE",
"autoscaling_limit_min_cu": 0.5,
"autoscaling_limit_max_cu": 4.0
}
}'
curl -X POST "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints?endpoint_id=my-compute" \
-H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
-H "Content-Type: application/json" \
-d '{
"spec": {
"endpoint_type": "ENDPOINT_TYPE_READ_WRITE",
"autoscaling_limit_min_cu": 0.5,
"autoscaling_limit_max_cu": 4.0
}
}' | jq
Cada ramificação pode ter apenas uma compute de leitura e escrita. Se você tentar criar uma segunda operação de leitura e compute no mesmo ramo, as operações falharão. Para aumentar a capacidade de consulta, crie réplicas de leitura.
Editar um compute
Você pode editar um compute para alterar seu tamanho, configuração de dimensionamento automático ou configurações de escalonamento para zero.
Para editar um compute:
- UI
- Python SDK
- Java SDK
- CLI
- curl
- Acesse tab de computação da sua filial no aplicativo Lakebase.
- Clique em Editar para o compute, ajuste suas configurações e clique em Salvar .

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Endpoint, EndpointSpec, FieldMask
w = WorkspaceClient()
# Update a single field (max CU)
endpoint_spec = EndpointSpec(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.spec.autoscaling_limit_max_cu}")
Para atualizar vários campos, inclua-os tanto na especificação quanto na máscara de atualização:
# Update multiple fields (min and max CU)
endpoint_spec = EndpointSpec(
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.spec.autoscaling_limit_min_cu}")
print(f"Updated max CU: {result.spec.autoscaling_limit_max_cu}")
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 quanto 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");
# 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
}
}'
# 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
As alterações nas configurações compute entram em vigor imediatamente e podem causar breves interrupções de conexão durante a reinicialização.
Reinicie um compute
Reinicie um compute para aplicar atualizações, resolver problemas de desempenho ou obter alterações de configuração.
Para reiniciar um compute:
- Acesse tab de computação da sua filial no aplicativo Lakebase.
- Clique no
No menu do compute, selecione Reiniciar e confirme as operações.
Reiniciar um compute interrompe todas as conexões ativas. Configure seus aplicativos para se reconectarem automaticamente e evitar interrupções prolongadas.
Excluir um compute
Você pode excluir o compute primário de uma ramificação. No entanto, é necessário um compute para conectar-se a uma filial e acessar seus dados.
Para excluir um compute:
- UI
- Python SDK
- Java SDK
- CLI
- curl
- Acesse tab de computação da sua filial no aplicativo Lakebase.
- Clique em Editar para o compute e, em seguida, clique em Excluir compute na parte inferior da caixa de diálogo.
from databricks.sdk import WorkspaceClient
w = WorkspaceClient()
# Delete endpoint
w.postgres.delete_endpoint(
name="projects/my-project/branches/production/endpoints/my-compute"
).wait()
print("Endpoint deleted")
As operações de exclusão são assíncronas. O método .wait() bloqueia até que a exclusão seja concluída.
import com.databricks.sdk.WorkspaceClient;
WorkspaceClient w = new WorkspaceClient();
// Delete endpoint
w.postgres().deleteEndpoint(
"projects/my-project/branches/production/endpoints/my-compute"
);
System.out.println("Delete initiated");
# Delete a compute
databricks postgres delete-endpoint projects/my-project/branches/production/endpoints/my-compute
curl -X DELETE "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute" \
-H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq
Resposta:
{
"name": "projects/my-project/branches/production/endpoints/my-compute/operations/...",
"done": true,
"response": {
"@type": "type.googleapis.com/google.protobuf.Empty"
}
}