Zarządzanie obliczeniami

Usługa obliczeniowa to zwirtualizowana usługa, która obsługuje Postgres dla projektów Lakebase. Każdy oddział ma jedno podstawowe obliczenie (z możliwością odczytu i zapisu). Obliczenia są wymagane do nawiązania połączenia z gałęzią i uzyskania dostępu do jej danych. Aby zapoznać się z omówieniem relacji obliczeń i punktów końcowych, zobacz Obliczenia i punkty końcowe.

Informacje o obliczeniach

Omówienie obliczeń

Zasoby obliczeniowe zapewniają moc obliczeniową i pamięć wymaganą do wykonywania zapytań, zarządzania połączeniami i obsługi operacji bazy danych. Każdy projekt ma podstawowe obliczenia odczytu i zapisu dla swojej gałęzi domyślnej.

Aby nawiązać połączenie z bazą danych w gałęzi, należy użyć obliczeń skojarzonych z tą gałęzią. Większe obliczenia zużywają więcej godzin obliczeniowych w tym samym okresie aktywnego czasu niż mniejsze obliczenia.

Identyfikatory obliczeniowe

Każde środowisko obliczeniowe ma trzy identyfikatory, dostępne z menu Pobierz identyfikator na karcie Obliczenia:

Nazwa hosta w parametry połączenia używa UID a nie nazwy obliczeniowej.

Ustalanie rozmiaru zasobów obliczeniowych

Dostępne rozmiary obliczeniowe

Usługa Lakebase Postgres obsługuje następujące rozmiary obliczeniowe:

• Skalowanie automatyczne oblicza: od 0,5 CU do 64 CU (0,5, a następnie liczba całkowita zwiększa się: 1, 2, 3... 64)
• Większe jednostki obliczeniowe o stałej wielkości: od 65 CU do 112 CU

Co znajduje się w jednostce obliczeniowej?

Każda jednostka obliczeniowa (CU) przydziela około 2 GB pamięci RAM dla instancji bazy danych wraz ze wszystkimi skojarzonymi zasobami CPU i lokalnymi dyskami SSD. Skalowanie w górę zwiększa te zasoby liniowo. Usługa Postgres dystrybuuje przydzieloną pamięć między wieloma składnikami:

• Bufory pamięci bazy danych
• Pamięć procesu roboczego
• Inne procesy ze stałymi wymaganiami dotyczącymi pamięci

Wydajność różni się w zależności od rozmiaru danych i złożoności zapytań. Przed skalowaniem, przetestuj i zoptymalizuj zapytania. Pamięć skalują się automatycznie.

Specyfikacje obliczeniowe

Limity połączeń dla jednostek obliczeniowych z automatycznym skalowaniem: Gdy włączone jest automatyczne skalowanie, maksymalna liczba połączeń jest określana przez mniejszą z dwóch wartości: maksymalną liczbę CU i 8× minimalną liczbę CU. Jeśli na przykład skonfigurujesz skalowanie automatyczne z zakresu od 2 do 8 CU, limit połączenia wynosi 1795 (limit dla 8 cu).

Limity połączeń repliki do odczytu: Limity połączeń przetwarzania repliki do odczytu są synchronizowane z podstawowymi ustawieniami przetwarzania operacji odczytu i zapisu. Aby uzyskać szczegółowe informacje, zobacz Zarządzanie replikami do odczytu .

Wskazówki dotyczące określania rozmiaru

Podczas wybierania rozmiaru obliczeniowego należy wziąć pod uwagę następujące czynniki:

Optymalna strategia ustalania rozmiaru

Wybierz rozmiar obliczeniowy na podstawie wymagań dotyczących danych:

• Pełny zestaw danych w pamięci: wybierz rozmiar obliczeniowy, który może przechowywać cały zestaw danych w pamięci, aby uzyskać najlepszą wydajność
• Zestaw roboczy w pamięci: w przypadku dużych zestawów danych upewnij się, że często używane dane mieszczą się w pamięci
• Limity połączeń: wybierz rozmiar, który obsługuje przewidywane maksymalne połączenia współbieżne

Skalowanie automatyczne

Usługa Lakebase obsługuje konfiguracje obliczeń o stałym rozmiarze i skalowaniu automatycznym. Skalowanie automatyczne dynamicznie dostosowuje zasoby obliczeniowe na podstawie zapotrzebowania na obciążenia, optymalizując zarówno wydajność, jak i koszt.

Limit skalowania automatycznego: Skalowanie automatyczne jest obsługiwane w przypadku obliczeń do 64 CU (128 GB). W przypadku obciążeń wymagających więcej niż 64 CU dostępne są większe instancje obliczeniowe o stałym rozmiarze: 80, 96 lub 112 CU.

Konfigurowanie skalowania automatycznego

Aby włączyć lub dostosować skalowanie automatyczne dla obliczeń, edytuj obliczenia i użyj suwaka, aby ustawić minimalne i maksymalne rozmiary obliczeniowe.

Aby zapoznać się z omówieniem sposobu działania skalowania automatycznego, zobacz Autoskalowanie.

Zagadnienia dotyczące skalowania automatycznego

Aby uzyskać optymalną wydajność skalowania automatycznego:

• Ustaw minimalny rozmiar obliczeniowy wystarczająco duży, aby buforować zestaw roboczy w pamięci
• Należy wziąć pod uwagę, że niska wydajność może wystąpić do momentu skalowania obliczeń w górę i buforowania danych
• Limity połączeń zależą od mniejszej z dwóch wartości: maksymalnej wartości CU i 8 × minimalnej wartości CU

Ograniczenia zakresu skalowania automatycznego: różnica między maksymalnymi i minimalnymi rozmiarami obliczeniowymi nie może przekraczać 16 CU (czyli max - min ≤ 16 CU). Na przykład można skonfigurować skalowanie automatyczne z zakresu od 8 do 24 CU lub z 48 do 64 CU, ale nie z 0,5 do 32 CU (co byłoby zakresem 31,5 CU). Suwak w aplikacji Lakebase automatycznie wymusza to ograniczenie. W przypadku obciążeń roboczych wymagających więcej niż 64 CU należy użyć większych instancji obliczeniowych o stałym rozmiarze, o wielkości do 112 CU.

Skalowanie do zera

Funkcja skalowania do zera usługi Lakebase automatycznie przenosi zasoby obliczeniowe do stanu bezczynności po okresie braku aktywności, co zmniejsza koszty baz danych, które nie są stale aktywne.

Skalowanie do zera jest dostępne tylko dla obliczeń o wartości 32 CU lub mniej. Dla obliczeń skalujących automatycznie maksymalny rozmiar musi wynosić 32 CU lub mniejszy. Większe zasoby obliczeniowe nie mogą korzystać ze skalowania do zera.

Aby zapoznać się z omówieniem działania skalowania do zera, zobacz Skalowanie do zera. Aby skonfigurować skalowanie do zera dla obliczeń, zobacz Konfigurowanie skalowania do zera.

Tworzenie obliczeń i zarządzanie nimi

Przegląd obliczeń

Wyświetlanie w interfejsie użytkownika

Aby wyświetlić obliczenia dla gałęzi, przejdź do strony Gałęzie projektu w aplikacji Lakebase i wybierz gałąź, aby wyświetlić kartę Obliczenia .

Karta Obliczenia zawiera informacje o wszystkich obliczeniach skojarzonych z gałęzią. Informacje wyświetlane na karcie Obliczenia zostały opisane w poniższej tabeli.

Dla każdego środowiska obliczeniowego można wykonywać następujące czynności:

• Kliknij przycisk Połącz , aby otworzyć okno dialogowe połączenia ze szczegółami połączenia dla gałęzi skojarzonej z obliczeniami. Okno dialogowe zawiera przełącznik Puli połączeń dla natywnych ról haseł Postgres. Zobacz Nawiązywanie połączenia z bazą danych i Używanie puli połączeń.
• Kliknij przycisk Edytuj , aby zmodyfikować rozmiar obliczeniowy (stały lub automatyczny zakres skalowania) i skonfigurować ustawienia skalowania do zera. Zobacz Edytowanie obliczeń.
• Kliknij ikonę menu, aby uzyskać dostęp do dodatkowych opcji:
  • Monitorowanie aktywności: wyświetlanie działań obliczeniowych i metryk wydajności. Zobacz Monitorowanie bazy danych.
  • Uruchom ponownie środowisko obliczeniowe: uruchom ponownie środowisko obliczeniowe, aby rozwiązać problemy z połączeniem lub zastosować zmiany konfiguracji. Zobacz Ponowne uruchamianie obliczeń.

Aby dodać replikę do odczytu do gałęzi, kliknij pozycję Dodaj replikę do odczytu. Repliki do odczytu to obliczenia tylko do odczytu, które umożliwiają skalowanie w poziomie, umożliwiając odciążanie obciążenia odczytu z podstawowych obliczeń. Zobacz Repliki do odczytu i Zarządzanie replikami do odczytu.

Programistyczne pozyskiwanie zasobów obliczeniowych

Aby uzyskać szczegółowe informacje na temat określonej jednostki obliczeniowej przy użyciu interfejsu API Postgres:

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

W zestawie SDK uzyskaj dostęp do hosta za pośrednictwem ( endpoint.status.hosts.host nie endpoint.status.host).

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

skręt

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

Obliczanie listy programowo

Aby wyświetlić listę wszystkich obliczeń i replik do odczytu dla gałęzi przy użyciu interfejsu API Postgres:

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

W zestawie SDK uzyskaj dostęp do hosta za pośrednictwem ( endpoint.status.hosts.host nie endpoint.status.host).

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

skręt

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

Edytowanie obliczeń

Możesz edytować obliczenia, aby zmienić jego rozmiar, konfigurację skalowania automatycznego lub ustawienia skalowania do zera. Nazwy obliczeniowe są tylko do odczytu i nie można ich zmienić.

Aby edytować obliczenia:

interfejs użytkownika

1. Przejdź do karty Obliczenia w Twojej gałęzi w aplikacji Lakebase.
2. Kliknij przycisk Edytuj dla obliczeń, dostosuj ustawienia, a następnie kliknij przycisk Zapisz.

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

Aby zaktualizować wiele pól, dołącz je zarówno do specyfikacji, jak i maski aktualizacji:

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

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

Aby zaktualizować wiele pól, dołącz je zarówno do specyfikacji, jak i maski aktualizacji:

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

skręt

# 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

Konfigurowanie skalowania do zera

Aby skonfigurować skalowanie do zera, uwzględnij spec.suspension w masce aktualizacji. Ustaw suspend_timeout_duration wartość (60s–604800s), aby zdefiniować limit czasu braku aktywności lub no_suspension: true wyłączyć go. Nie ustawiaj obu tych jednocześnie. Ustawienie no_suspension: false jest nieprawidłowe i zwraca błąd. Domyślnie dla gałęzi production włączono skalowanie do zera z 24-godzinnym limitem czasu.

Skalowanie do zera jest dostępne tylko dla obliczeń o wartości 32 CU lub mniejszych (dla obliczeń automatycznego skalowania maksymalny rozmiar musi wynosić 32 CU lub mniej). Ustawienie limitu czasu wstrzymania dla większego zasobu obliczeniowego powoduje błąd.

interfejs użytkownika

1. Przejdź do karty Obliczenia w Twojej gałęzi w aplikacji Lakebase.
2. Kliknij przycisk Edytuj dla obliczeń, a następnie włącz lub wyłącz ustawienie skalowania do zera. Po włączeniu skonfiguruj limit czasu braku aktywności z zakresu od 60 sekund do 7 dni.
3. Kliknij Zapisz.

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

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

skręt

# 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

Wyłącz lub włącz zasób obliczeniowy

Wyłączenie obliczeń zawiesza je i blokuje wszystkie nowe połączenia. W przeciwieństwie do skalowania do zera wyłączonego zasobu obliczeniowego nie można wybudzić ani za pomocą próby połączenia, ani z poziomu aplikacji Lakebase. Aby ją ponownie włączyć, użyj interfejsu API.

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

Aby sprawdzić, czy środowisko obliczeniowe jest obecnie wyłączone, należy odczytać wartość ze stanu punktu końcowego. Ustawiono wartość na spec.disabled, ale odczytasz ją z powrotem z elementu 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
    }
  }'

Aby sprawdzić, czy środowisko obliczeniowe jest obecnie wyłączone, odczyt status.disabled z punktu końcowego:

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

skręt

# 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

Aby sprawdzić, czy środowisko obliczeniowe jest obecnie wyłączone, odczyt status.disabled z punktu końcowego:

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

Ponowne uruchamianie obliczeń

Uruchom ponownie środowisko obliczeniowe, aby zastosować aktualizacje, rozwiązać problemy z wydajnością lub pobrać zmiany konfiguracji.

Aby ponownie uruchomić środowisko obliczeniowe:

1. Przejdź do karty Obliczenia w Twojej gałęzi w aplikacji Lakebase.
2. Kliknij menu dla obliczeń, wybierz pozycję Uruchom ponownie i potwierdź operację.

Dodatkowe zasoby

• Panel metryk
• Skalowanie automatyczne
• Skalowanie do zera
• Repliki do odczytu