Berekeningen beheren

Een compute is een gevirtualiseerde dienst die Postgres uitvoert voor uw Lakebase-projecten. Elke vertakking heeft één primaire berekening (lezen/schrijven). Er is een computersysteem vereist om verbinding te maken met een vestiging en toegang te krijgen tot zijn gegevens. Zie Computes en eindpunten voor een overzicht van de relatie tussen berekeningen en eindpunten.

Inzicht in berekeningen

Overzicht van computing

Rekenresources bieden de verwerkingskracht en het geheugen die nodig zijn voor het uitvoeren van query's, het beheren van verbindingen en het verwerken van databasebewerkingen. Elk project heeft een primaire rekenkracht voor lezen/schrijven voor de standaardvertakking.

Als u verbinding wilt maken met een database in een vertakking, moet u een rekenproces gebruiken dat aan die vertakking is gekoppeld. Grotere berekeningen verbruiken meer rekenuren gedurende dezelfde periode van actieve tijd dan kleinere berekeningen.

Computeridentificatoren

Elke berekening heeft drie id's die toegankelijk zijn via het menu Id ophalen op het tabblad Berekeningen:

De hostnaam in uw verbindingsreeks gebruikt de UID, niet de rekennaam.

Berekening van de computergrootte

Beschikbare rekengrootten

Lakebase Postgres ondersteunt de volgende rekengrootten:

• Berekeningen voor automatisch schalen: 0,5 CU tot 64 CU (0,5, en vervolgens gehele getallen: 1, 2, 3... 64)
• Grotere berekeningen met vaste grootte: 65 CU tot 112 CU

Wat is er in een rekeneenheid?

Elke compute-eenheid (CU) wijst ongeveer 2 GB RAM toe aan het database-exemplaar, samen met alle bijbehorende CPU- en lokale SSD-resources. Door omhoog te schalen worden deze resources lineair verhoogd. Postgres distribueert het toegewezen geheugen over meerdere onderdelen:

• Databasecaches
• Werkgeheugen
• Andere processen met vaste geheugenvereisten

Prestaties variëren op basis van de gegevensgrootte en querycomplexiteit. Voordat u query's gaat schalen, testen en optimaliseren. Opslag wordt automatisch geschaald.

Berekeningsspecificaties

Verbindingslimieten voor autoscaling-computes: wanneer automatisch schalen is ingeschakeld, wordt het maximale aantal verbindingen bepaald door de laagste waarde van uw maximale CU en 8× uw minimale CU. Als u bijvoorbeeld automatisch schalen configureert tussen 2-8 CU, is uw verbindingslimiet 1795 (de limiet voor 8 CU).

Verbindingslimieten voor leesreplica's: Verbindingslimieten voor leesreplica's worden gesynchroniseerd met uw primaire computerinstellingen voor lezen en schrijven. Zie Leesreplica's beheren voor meer informatie.

Richtlijnen voor het aanpassen van de grootte

Houd bij het selecteren van een rekenkracht rekening met de volgende factoren:

Optimale groottestrategie

Selecteer een rekenkracht op basis van uw gegevensvereisten:

• Volledige gegevensset in het geheugen: kies een rekenkracht die uw volledige gegevensset in het geheugen kan bevatten voor de beste prestaties
• Werkset in het geheugen: Voor grote gegevenssets zorgt u ervoor dat uw veelgebruikte gegevens in het geheugen passen
• Verbindingslimieten: Selecteer een grootte die ondersteuning biedt voor de verwachte maximale gelijktijdige verbindingen

Automatisch schalen

Lakebase biedt ondersteuning voor rekenconfiguraties met een vaste grootte en automatische schaalaanpassing. Met automatisch schalen worden rekenresources dynamisch aangepast op basis van de vraag naar workloads, waardoor zowel de prestaties als de kosten worden geoptimaliseerd.

Limiet voor automatisch schalen: Automatisch schalen wordt ondersteund voor berekeningen tot 64 CU (128 GB). Voor workloads waarvoor meer dan 64 CU is vereist, zijn grotere berekeningen met een vaste grootte van 80, 96 of 112 CU beschikbaar.

Automatische schaalaanpassing configureren

Als u automatische schaalaanpassing voor een berekening wilt in- of aanpassen, bewerkt u de berekening en gebruikt u de schuifregelaar om minimale en maximale rekengrootten in te stellen.

Zie Automatisch schalen voor een overzicht van hoe automatisch schalen werkt.

Overwegingen voor automatisch schalen

Voor optimale prestaties van automatisch schalen:

• Stel de minimum rekenkracht in die groot genoeg is om uw werkset in het geheugen te cachen.
• Houd er rekening mee dat er slechte prestaties kunnen optreden totdat de rekenkracht omhoog wordt geschaald en uw gegevens in de cache worden opgeslagen
• Uw verbindingslimieten zijn gebaseerd op de laagste van uw maximale CU en 8× uw minimale CU

Beperkingen voor automatisch schalen: het verschil tussen uw maximale en minimale rekenkracht mag niet groter zijn dan 16 CU (dat wil max - min ≤ 16 CUgezegd). U kunt bijvoorbeeld automatische schaalaanpassing configureren van 8 tot 24 CU, of van 48 tot 64 CU, maar niet van 0,5 tot 32 CU (wat een bereik van 31,5 CU is). Met de schuifregelaar in de Lakebase-app wordt deze beperking automatisch afgedwongen. Voor workloads waarvoor meer dan 64 CU is vereist, gebruikt u grotere berekeningen met een vaste grootte tot 112 CU.

Schalen naar nul

De functie scale-to-zero van Lakebase zet automatisch een berekening over in een niet-actieve status na een periode van inactiviteit, waardoor de kosten voor databases die niet continu actief zijn, worden verlaagd.

Zie Schalen naar nul voor een overzicht van hoe schalen naar nul werkt. Zie Schaal naar nul configureren om schaal naar nul te configureren voor een berekening.

Berekeningen maken en beheren

Berekeningen weergeven

Weergeven in de gebruikersinterface

Als u de berekeningen voor een vertakking wilt bekijken, gaat u naar de pagina Branches van uw project in de Lakebase-app en selecteert u een vertakking om het tabblad Computes weer te geven.

Op het tabblad Berekeningen wordt informatie weergegeven over alle berekeningen die zijn gekoppeld aan de vertakking. De informatie die op het tabblad Berekeningen wordt weergegeven, wordt beschreven in de volgende tabel.

Voor elke berekening kunt u het volgende doen:

• Klik op Verbinding maken om een verbindingsdialoogvenster te openen met verbindingsgegevens voor de vertakking die is gekoppeld aan de berekening. Het dialoogvenster bevat een wisselknop voor verbindingspooling voor native Postgres-wachtwoordrollen. Zie Verbinding maken met uw database en verbindingspooling gebruiken.
• Klik op Bewerken om de rekengrootte (vast of automatisch schalen) te wijzigen en de instellingen voor schaal naar nul te configureren. Zie Een berekening bewerken.
• Klik op het menupictogram voor toegang tot extra opties:
  • Activiteit bewaken: Rekenactiviteit en prestatiegegevens weergeven. Zie Uw database controleren.
  • Rekenproces opnieuw opstarten: start de berekening opnieuw om verbindingsproblemen op te lossen of configuratiewijzigingen toe te passen. Zie Een rekenproces opnieuw opstarten.

Als u een leesreplica-berekening wilt toevoegen aan de vertakking, klikt u op Leesreplica toevoegen. Leesreplica's zijn alleen-lezen-instanties die horizontale schaalvergroting mogelijk maken door leesworkloads van uw primaire instantie over te dragen. Zie Leesreplica's en Leesreplica's beheren.

Programmatisch een rekenproces ophalen

Voor meer informatie over een specifieke berekening met behulp van de Postgres-API:

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

Verkrijg in de SDK toegang tot de host via endpoint.status.hosts.host (niet 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 (Command Line Interface)

# 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

Berekeningen programmatisch weergeven

Alle berekeningen en leesreplica's voor een vertakking weergeven met behulp van de Postgres-API:

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

Verkrijg in de SDK toegang tot de host via endpoint.status.hosts.host (niet 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 (Command Line Interface)

# 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

Een rekenproces bewerken

U kunt een berekening bewerken om de grootte, de configuratie voor automatisch schalen of de instellingen voor schaal naar nul te wijzigen. Rekennamen hebben het kenmerk Alleen-lezen en kunnen niet worden gewijzigd.

Een berekening bewerken:

UI (Gebruikersinterface)

1. Ga naar het tabblad Computes van je branch in de Lakebase App.
2. Klik op Bewerken voor de berekening, pas uw instellingen aan en klik op Opslaan.

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

Als u meerdere velden wilt bijwerken, moet u deze opnemen in zowel de specificatie als het updatemasker:

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

Als u meerdere velden wilt bijwerken, moet u deze opnemen in zowel de specificatie als het updatemasker:

// 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 (Command Line Interface)

# 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

Schaal naar nul configureren

Als u schalen naar nul wilt configureren, neemt u spec.suspension op in het updatemask. Stel suspend_timeout_duration (60s-604800s) in om de time-out voor inactiviteit te definiëren of no_suspension: true om deze uit te schakelen. Stel niet beide in. De instelling no_suspension: false is ongeldig en retourneert een fout. De production branch is standaard ingesteld op schalen naar nul, met een time-out van 24 uur.

UI (Gebruikersinterface)

1. Ga naar het tabblad Computes van je branch in de Lakebase App.
2. Klik op Bewerken voor de berekening en schakel de instelling voor schalen naar nul in of uit. Wanneer deze optie is ingeschakeld, configureert u de time-out voor inactiviteit tussen 60 seconden en 7 dagen.
3. Klik op Opslaan.

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 (Command Line Interface)

# 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

Een rekenproces uitschakelen of inschakelen

Als u een berekening uitschakelt, wordt deze onderbroken en worden alle nieuwe verbindingen geblokkeerd. In tegenstelling tot schalen naar nul kan een uitgeschakelde berekening niet worden geactiveerd door een verbindingspoging of vanuit de Lakebase-app. Als u deze opnieuw wilt inschakelen, gebruikt u de 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()

Als u wilt controleren of een berekening momenteel is uitgeschakeld, leest u de waarde uit de status van het eindpunt. U stelt de waarde in spec.disabled, maar u leest deze terug van 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 (Command Line Interface)

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

Om te controleren of een compute-instance momenteel is uitgeschakeld, leest u status.disabled van het eindpunt:

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

Om te controleren of een compute-instance momenteel is uitgeschakeld, leest u status.disabled van het eindpunt:

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

Een rekenproces opnieuw starten

Start een berekening opnieuw om updates toe te passen, prestatieproblemen op te lossen of configuratiewijzigingen op te halen.

Een rekenproces opnieuw starten:

1. Ga naar het tabblad Computes van je branch in de Lakebase App.
2. Klik op het voor het rekentoestel, selecteer Opnieuw opstarten en bevestig de bewerking.

Aanvullende informatiebronnen

• Dashboard met metrische gegevens
• Autoscaling
• Schalen naar nul
• Leesreplica's