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 automatische schaalaanpassing: 0,5 CU tot 32 CU (0,5, vervolgens gehele getallen: 1, 2, 3... 16, en vervolgens 24, 28, 32)
• Grotere berekeningen met vaste grootte: 36 CU tot 112 CU (36, 40, 44, 48, 52, 56, 60, 64, 72, 80, 88, 96, 104, 112)

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 berekeningen voor automatisch schalen: wanneer automatisch schalen is ingeschakeld, wordt het maximum aantal verbindingen bepaald door de maximale CU-grootte in uw bereik voor automatisch schalen. Als u bijvoorbeeld automatische schaalaanpassing tussen 2-8 CU configureert, is de verbindingslimiet 1678 (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: Automatische schaalaanpassing wordt ondersteund voor berekeningen tot 32 CU. Voor workloads waarvoor meer dan 32 CU is vereist, zijn grotere berekeningen met vaste grootte van 36 CU tot 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 maximale rekenkracht in uw bereik voor automatisch schalen

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 16 tot 32 CU, maar niet van 0,5 tot 32 CU (wat een bereik van 31,5 CU is). Deze beperking zorgt voor beheerbaar schaalgedrag terwijl u nog steeds flexibiliteit biedt. Met de schuifregelaar in de Lakebase-app wordt deze beperking automatisch afgedwongen wanneer u uw bereik voor automatisch schalen configureert. Voor workloads waarvoor meer dan 32 CU is vereist, gebruikt u grotere berekeningen met een vaste grootte.

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.

Schaal naar nul configureren

Als u schaal naar nul wilt in- of aanpassen voor een berekening, bewerkt u de berekening en schakelt u de instelling voor schalen naar nul in. Wanneer deze optie is ingeschakeld, kunt u de time-out voor inactiviteit configureren.

Zie Schalen naar nul voor een overzicht van hoe schalen naar nul werkt.

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. Navigeer naar het tabblad Computes van uw tak 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

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. Navigeer naar het tabblad Computes van uw tak in de Lakebase-app.
2. Klik op het voor het rekentoestel, selecteer Opnieuw opstarten en bevestig de bewerking.

Verwante informatie

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