Gestire i calcoli

Un ambiente di calcolo è un servizio virtualizzato che esegue Postgres per i progetti Lakebase. Ogni ramo ha un'unità di calcolo primaria (lettura/scrittura). Un ambiente di calcolo è necessario per connettersi a un ramo e accedere ai relativi dati. Per una panoramica del modo in cui sono correlati i calcoli e gli endpoint, vedere Calcolo ed endpoint.

Informazioni sui calcoli

Panoramica del calcolo

Le risorse di calcolo forniscono la potenza di elaborazione e la memoria necessarie per eseguire query, gestire le connessioni e gestire le operazioni del database. Ogni progetto ha un calcolo primario di lettura/scrittura per il ramo predefinito.

Per connettersi a un database in un ramo, è necessario usare un calcolo associato a tale ramo. I calcoli di dimensioni maggiori utilizzano più ore di calcolo nello stesso periodo di tempo attivo rispetto ai calcoli più piccoli.

Identificatori di calcolo

Ogni calcolo ha tre identificatori, accessibili dal menu Recupera ID nella scheda Calcolo:

Il nome host nel stringa di connessione usa il UID e non il nome di calcolo.

Dimensionamento delle risorse di calcolo

Dimensioni di calcolo disponibili

Lakebase Postgres supporta le dimensioni di calcolo seguenti:

• Calcolo della scalabilità automatica: da 0,5 CU a 64 CU (0,5, quindi incrementi interi: 1, 2, 3... 64)
• Calcoli a dimensione fissa maggiori: da 65 CU a 112 CU

Che cos'è in un'unità di calcolo?

Ogni unità di calcolo (CU) alloca circa 2 GB di RAM all'istanza del database, insieme a tutte le risorse DI CPU e SSD locali associate. L'aumento delle prestazioni aumenta in modo lineare queste risorse. Postgres distribuisce la memoria allocata tra più componenti:

• Cache del database
• Memoria del lavoratore
• Altri processi con requisiti di memoria fissi

Le prestazioni variano in base alle dimensioni dei dati e alla complessità delle query. Prima di ridimensionare, testare e ottimizzare le query. L'archiviazione viene ridimensionata automaticamente.

Specifiche di calcolo

Limiti di connessione per le istanze di calcolo con scalabilità automatica: Quando la scalabilità automatica è abilitata, il numero massimo di connessioni è determinato dal valore inferiore tra il tuo CU massimo e 8× il tuo CU minimo. Ad esempio, se si configura la scalabilità automatica tra 2-8 CU, il limite di connessione è 1.795 (limite per 8 CU).

Limiti di connessione per le repliche di lettura: i limiti di connessione di calcolo delle repliche di lettura vengono sincronizzati con le impostazioni di calcolo primarie di lettura/scrittura. Vedi Gestire le repliche di lettura per maggiori dettagli.

Linee guida per il ridimensionamento

Quando si seleziona una dimensione di calcolo, considerare questi fattori:

Strategia di dimensionamento ottimale

Selezionare una dimensione di calcolo in base ai requisiti dei dati:

• Set di dati completo in memoria: scegliere una dimensione di calcolo che possa contenere l'intero set di dati in memoria per ottenere prestazioni ottimali
• Working set in memory: per set di dati di grandi dimensioni, assicurarsi che i dati a cui si accede di frequente siano caricati in memoria
• Limiti di connessione: selezionare una dimensione che supporti le connessioni simultanee previste

Scalabilità automatica

Lakebase supporta configurazioni di calcolo a dimensione fissa e scalabilità automatica. La scalabilità automatica regola in modo dinamico le risorse di calcolo in base alla domanda del carico di lavoro, ottimizzando sia le prestazioni che i costi.

Limite di scalabilità automatica: La scalabilità automatica è supportata per i calcoli fino a 64 CU (128 GB). Per i carichi di lavoro che richiedono più di 64 CU, sono disponibili calcoli di dimensioni fisse maggiori pari a 80, 96 o 112 CU.

Configurazione della scalabilità automatica

Per abilitare o regolare la scalabilità automatica per un calcolo, modificare il calcolo e usare il dispositivo di scorrimento per impostare le dimensioni di calcolo minime e massime.

Per una panoramica del funzionamento della scalabilità automatica, vedere Scalabilità automatica.

Considerazioni sulla scalabilità automatica

Per prestazioni ottimali di scalabilità automatica:

• Imposta la dimensione minima di calcolo abbastanza grande da memorizzare nella cache il tuo insieme di lavoro in memoria
• Si consideri che possono verificarsi prestazioni scarse fino a quando il calcolo aumenta e memorizza nella cache i dati
• I limiti di connessione si basano sul valore minore tra il numero massimo di CU e 8× il numero minimo di CU

Vincoli di intervallo di scalabilità automatica: la differenza tra il massimo e il minimo delle dimensioni di calcolo non può superare 16 CU (ovvero unità di calcolo, max - min ≤ 16 CU). Ad esempio, è possibile configurare la scalabilità automatica da 8 a 24 CU o da 48 a 64 CU, ma non da 0,5 a 32 CU (che sarebbe un intervallo cu di 31,5). Il cursore nell’app di Lakebase applica automaticamente questo vincolo. Per i carichi di lavoro che richiedono più di 64 CU, utilizzare compute a dimensione fissa più grandi, fino a 112 CU.

Riduzione automatica a zero

La funzionalità di scalabilità a zero di Lakebase esegue automaticamente la transizione di un calcolo in uno stato di inattività dopo un periodo di inattività, riducendo i costi per i database che non sono continuamente attivi.

Per una panoramica del funzionamento della scalabilità su zero, vedere Ridimensionare a zero. Per configurare la scalabilità su zero per un calcolo, vedere Configurare la scalabilità su zero.

Creare e gestire i calcoli

Visualizzare i calcoli

Visualizzazione nell'interfaccia utente

Per visualizzare i calcoli per un ramo, passare alla pagina Rami del progetto nell'app Lakebase e selezionare un ramo per visualizzarne la scheda Calcolo .

Nella scheda Calcolo vengono visualizzate informazioni su tutti i calcoli associati al ramo. Le informazioni visualizzate nella scheda Calcoli sono descritte nella tabella seguente.

Per ogni calcolo, è possibile:

• Fare clic su Connetti per aprire una finestra di dialogo di connessione con i dettagli di connessione per il ramo associato al calcolo. La finestra di dialogo include un'opzione pooling di connessioni per i ruoli con password nativi di Postgres. Vedere Connettersi al database e Usare il pool di connessioni.
• Fare clic su Modifica per modificare le dimensioni di calcolo (intervallo fisso o di scalabilità automatica) e configurare le impostazioni scale-to-zero. Vedere Modificare un ambiente di calcolo.
• Fare clic sull'icona del menu per accedere ad altre opzioni:
  • Monitorare l'attività: visualizzare le metriche delle prestazioni e delle attività di calcolo. Vedere Monitorare il database.
  • Riavviare il calcolo: riavviare il calcolo per risolvere i problemi di connessione o applicare le modifiche di configurazione. Vedere Riavviare un ambiente di calcolo.

Per aggiungere un calcolo di replica in lettura al ramo, fare clic su Aggiungi replica di lettura. Le repliche di lettura sono calcoli di sola lettura che consentono il ridimensionamento orizzontale consentendo di eseguire l'offload del carico di lavoro di lettura dal calcolo primario. Vedi Repliche di lettura e Gestione delle repliche di lettura.

Ottenere una risorsa di calcolo tramite programmazione

Per ottenere informazioni dettagliate su un ambiente di calcolo specifico usando l'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}")

Nell'SDK accedere all'host tramite endpoint.status.hosts.host (non endpoint.status.host).

JAVA SDK

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

curva

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

Elencare i calcoli a livello di codice

Per elencare tutte le repliche di calcolo e lettura per un ramo usando l'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()

Nell'SDK accedere all'host tramite endpoint.status.hosts.host (non endpoint.status.host).

JAVA SDK

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

curva

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

Modificare un ambiente di calcolo

È possibile modificare un calcolo per modificarne le dimensioni, la configurazione della scalabilità automatica o le impostazioni di scalabilità a zero. I nomi di calcolo sono di sola lettura e non possono essere rinominati.

Per modificare un ambiente di calcolo:

INTERFACCIA UTENTE

1. Vai alla scheda Computes del tuo branch nell’app Lakebase.
2. Fare clic su Modifica per il calcolo, modificare le impostazioni e fare clic su Salva.

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}")

Per aggiornare più campi, includerli sia nella specifica che nella maschera di aggiornamento:

# 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}")

JAVA SDK

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");

Per aggiornare più campi, includerli sia nella specifica che nella maschera di aggiornamento:

// 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
    }
  }'

curva

# 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

Configurare la scalabilità su zero

Per configurare la scalabilità su zero, includere spec.suspension nella maschera di aggiornamento. Impostare suspend_timeout_duration (60s-604800s) per definire il timeout di inattività o no_suspension: true disabilitarlo. Non impostarle entrambi. L'impostazione no_suspension: false non è valida e restituisce un errore. Per impostazione predefinita, il production ramo ha la scalabilità su zero abilitata con un timeout di 24 ore.

INTERFACCIA UTENTE

1. Vai alla scheda Computes del tuo branch nell’app Lakebase.
2. Fare clic su Modifica per il calcolo, quindi abilitare o disabilitare l'impostazione scale-to-zero. Se abilitata, configurare il timeout di inattività compreso tra 60 secondi e 7 giorni.
3. Fai clic su Salva.

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()

JAVA SDK

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

curva

# 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

Disabilitare o abilitare un ambiente di calcolo

La disabilitazione di un ambiente di calcolo lo sospende e blocca tutte le nuove connessioni. A differenza della scalabilità a zero, un calcolo disabilitato non può essere riattivato da un tentativo di connessione o dall'app Lakebase. Per riabilitarlo, usare l'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()

Per verificare se un'istanza di calcolo è attualmente disabilitata, leggere il valore dallo stato dell'endpoint. Hai impostato il valore su spec.disabled, ma lo rileggi da 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
    }
  }'

Per verificare se un ambiente di calcolo è attualmente disabilitato, leggere status.disabled dall'endpoint:

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

curva

# 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

Per verificare se un ambiente di calcolo è attualmente disabilitato, leggere status.disabled dall'endpoint:

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

Riavviare un ambiente di calcolo

Riavviare un ambiente di calcolo per applicare gli aggiornamenti, risolvere i problemi di prestazioni o selezionare le modifiche alla configurazione.

Per riavviare un ambiente di calcolo:

1. Vai alla scheda Computes del tuo branch nell’app Lakebase.
2. Fare clic Per il calcolo selezionare Riavvia e confermare l'operazione.

Risorse aggiuntive

• Dashboard delle metriche
• Scalabilità automatica
• Scala a zero
• Repliche in lettura