Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Diese Seite bietet einen Überblick über die Lakebase-API, einschließlich Authentifizierung, verfügbarer Endpunkte und gängiger Muster für die Arbeit mit der REST-API, der Databricks-CLI und den Databricks-SDKs (Python, Java, Go).
Für die vollständige Liste der Operationen und ihrer Parameter siehe die Postgres API-Referenz.
Hinweis
Einige Operationen sind noch in der Beta-Phase. Die Postgres-API-Referenz markiert den Status jeder Operation.
Authentifizierung
Die Lakebase-API verwendet OAuth-Authentifizierung auf Arbeitsflächenebene zur Verwaltung der Projektinfrastruktur (Projekterstellung, Konfiguration von Einstellungen usw.).
Hinweis
Zwei Arten von Konnektivität: Diese API ist für das Plattformmanagement gedacht (Erstellung von Projekten, Branches, Computes). Für datenbankzugriff (Herstellen einer Verbindung mit Abfragedaten):
- SQL-Clients (psql, pgAdmin, DBeaver): Verwenden Sie Lakebase OAuth-Token oder Postgres-Passwörter. Siehe Authentifizierung.
- Data API (RESTful HTTP): Verwenden Sie Lakebase OAuth-Tokens. Siehe Daten-API.
- Programmiersprachentreiber (psycopg, SQLAlchemy, JDBC): Verwenden Sie Lakebase OAuth-Token oder Postgres-Passwörter. Siehe Schnellstart.
Eine vollständige Erläuterung dieser beiden Authentifizierungsebenen finden Sie unter Authentifizierungsarchitektur.
Authentifizierung einrichten
Authentifizieren mithilfe der Databricks CLI:
databricks auth login --host https://your-workspace.cloud.databricks.com
Folgen Sie den Browseraufforderungen, um sich anzumelden. Die CLI speichert Ihr OAuth-Token unter ~/.databricks/token-cache.json.
Wählen Sie dann Ihre Zugriffsmethode aus:
Python SDK
Das SDK verwendet einheitliche Authentifizierung und verarbeitet automatisch OAuth-Token:
from databricks.sdk import WorkspaceClient
w = WorkspaceClient()
Java SDK
Das SDK verwendet einheitliche Authentifizierung und verarbeitet automatisch OAuth-Token:
import com.databricks.sdk.WorkspaceClient;
WorkspaceClient w = new WorkspaceClient();
Befehlszeilenschnittstelle (CLI)
Befehle verwenden automatisch das zwischengespeicherte Token:
databricks postgres list-projects
cURL
Generiere ein Token und stelle die URL deines Arbeitsbereichs für direkte API-Aufrufe ein. Die Curl-Beispiele in den Lakebase-Dokumenten gehen von diesen beiden Umweltvariablen aus:
export WORKSPACE="https://your-workspace.cloud.databricks.com"
export DATABRICKS_TOKEN=$(databricks auth token | jq -r .access_token)
curl -X GET "$WORKSPACE/api/2.0/postgres/projects" \
-H "Authorization: Bearer ${DATABRICKS_TOKEN}"
OAuth-Token laufen nach einer Stunde ab. Regenerieren Sie nach Bedarf.
Weitere Details finden Sie unter Autorisieren des Benutzerzugriffs auf Databricks mit OAuth.
Verfügbare Endpunkte
Die Postgres-API verwendet den Basispfad /api/2.0/postgres/. Compute-Richtlinien und Ressourcenberechtigungen verwenden unterschiedliche API-Pfade.
serverlose Rechenrichtlinien
Important
In Arbeitsbereichen, die in der serverlosen Rechenrichtlinie Private Preview registriert sind:
- Die Erstellung eines Lakebase-Projekts erfordert
CAN_USEoderCAN_MANAGEfür eine Richtlinie, die Lakebase erlaubt. - Die Änderung der Rechenkapazität oder der Scale-to-zero-Einstellungen erfordert
CAN_MANAGEfür das Lakebase-Projekt undCAN_USEoderCAN_MANAGEfür dessen Richtlinie. Dies gilt auch dann, wenn die Richtlinie keine Grenze für die Einstellung setzt. - Das Ändern des Anzeigenamens eines Lakebase-Projekts erfordert nur
CAN_MANAGEfür das Lakebase-Projekt. - Das Ersetzen der Richtlinie erfordert
CAN_MANAGEauf das Lakebase-Projekt undCAN_USEoderCAN_MANAGEauf beide Richtlinien. Wenn Siespec.compute_policy_iddeaktivieren, wird die Standard-Lakebase-Richtlinie als Ersatz zugewiesen.
Aktualisierte Einstellungen müssen die aktuellen Einschränkungen der Richtlinie erfüllen und die erforderlichen Tag-Schlüssel-Wert-Paare beibehalten. Siehe Berechtigungen für Konfigurationsänderungen.
Um Vorschau-Zugriff zu beantragen, wenden Sie sich bitte an Ihr Databricks-Kontoteam.
Richtlinien können die Rechenkapazität und die Leerlaufzeit vor der Skalierung auf null begrenzen und Tags durchsetzen. Richtlinienverwaltung ist ausschließlich API-basiert und verwendet /api/2.0/policies/compute.
Legen Sie spec.compute_policy_id beim Erstellen eines Lakebase-Projekts fest, um eine Rechenrichtlinie auszuwählen. Für Richtlinienverwaltung und Berechtigungen siehe Serverless-Rechenrichtlinien verwalten. Für Postgres-API-Beispiele, die Lakebase-Projektoperationen und Rechenupdates abdecken, siehe "Eine Richtlinie mit Lakebase-Projekten verwenden". Das separate spec.budget_policy_id Feld wählt eine serverlose Nutzungsrichtlinie für die Kostenzuweisung aus.
Um die angehängte Richtlinie zu ändern, siehe Richtlinie eines Lakebase-Projekts ersetzen.
Projekte
| Operation | Methode | Endpunkt | Dokumentation |
|---|---|---|---|
| Projekt erstellen | POST |
/projects |
Erstellen eines Projekts |
| Projekt aktualisieren | PATCH |
/projects/{project_id} |
Allgemeine Einstellungen |
| Löschen eines Projekts | DELETE |
/projects/{project_id} |
Ein Projekt löschen |
| Projekt abrufen | GET |
/projects/{project_id} |
Projektdetails abrufen |
| Projekte auflisten | GET |
/projects |
Projekte auflisten |
Branches
| Operation | Methode | Endpunkt | Dokumentation |
|---|---|---|---|
| Branch erstellen | POST |
/projects/{project_id}/branches |
Erstelle einen Zweig |
| Eine Verzweigung aktualisieren | PATCH |
/projects/{project_id}/branches/{branch_id} |
Branch-Einstellungen aktualisieren |
| Verzweigung löschen | DELETE |
/projects/{project_id}/branches/{branch_id} |
Löschen eines Branch |
| Verzweigung abrufen | GET |
/projects/{project_id}/branches/{branch_id} |
Branches anzeigen |
| Zweige auflisten | GET |
/projects/{project_id}/branches |
Branches auflisten |
Schnappschüsse
| Operation | Methode | Endpunkt | Dokumentation |
|---|---|---|---|
| Erstellen einer Momentaufnahme | POST |
/projects/{project_id}/snapshots |
Erstellen Sie einen Snapshot |
| Snapshot löschen | DELETE |
/projects/{project_id}/snapshots/{snapshot_id} |
Löschen einer Momentaufnahme |
| Momentaufnahme abrufen | GET |
/projects/{project_id}/snapshots/{snapshot_id} |
Snapshots abrufen und auflisten |
| Momentaufnahmen auflisten | GET |
/projects/{project_id}/snapshots |
Snapshots abrufen und auflisten |
| Snapshot wiederherstellen (Sprung aus Snapshot erstellen) | POST |
/projects/{project_id}/branches |
Wiederherstellung aus einem Snapshot |
Endpunkte (Compute-Instanzen und Lesereplikate)
In der API wird eine Berechnung als Endpunkt bezeichnet. Eine konzeptionelle Übersicht finden Sie unter Computes und Endpunkte.
Die folgende Tabelle ordnet UI-Konzepte ihren API-Entsprechungen zu:
| Ui-Konzept | API-Ressource oder -Feld | Dokumentation |
|---|---|---|
| Primäre Berechnung | Endpunkt mit endpoint_type: ENDPOINT_TYPE_READ_WRITE |
Compute-Instanzen verwalten |
| Lesereplikat | Endpunkt mit endpoint_type: ENDPOINT_TYPE_READ_ONLY |
Read-Replicas verwalten |
| Hohe Verfügbarkeit |
group Feld (EndpointGroupSpec) in der Endpunktspezifikation |
Hohe Verfügbarkeit verwalten |
| Berechnungskennungen (UID, Ressourcenname) |
uid und name (vollständiger Ressourcenpfad) auf dem Endpunkt-Objekt |
Berechnungskennungen |
Verfügbare Vorgänge
| Operation | Methode | Endpunkt | Dokumentation |
|---|---|---|---|
| Endpunkt erstellen | POST |
/projects/{project_id}/branches/{branch_id}/endpoints |
Erstellen Sie eine Read-Replica |
| Endpunkt aktualisieren | PATCH |
/projects/{project_id}/branches/{branch_id}/endpoints/{endpoint_id} |
Compute-Instanz bearbeiten / Lesereplik bearbeiten / Hochverfügbarkeit verwalten |
| Löschen eines Endpunkts | DELETE |
/projects/{project_id}/branches/{branch_id}/endpoints/{endpoint_id} |
Löschen Sie eine Lesereplik |
| Endpunkt abrufen | GET |
/projects/{project_id}/branches/{branch_id}/endpoints/{endpoint_id} |
Computes anzeigen |
| Endpunkte auflisten | GET |
/projects/{project_id}/branches/{branch_id}/endpoints |
Computes anzeigen |
Lese-Schreib-Endpunkte können nicht direkt gelöscht werden. Lösche den übergeordneten Branch, um sie zu entfernen. Um Rechenkosten zu vermeiden und dabei den Branch zu behalten, setzen Sie spec.disabled auf true. Siehe Deaktivieren oder Aktivieren eines Rechengeräts.
Rollen
| Operation | Methode | Endpunkt | Dokumentation |
|---|---|---|---|
| Rollen auflisten | GET |
/projects/{project_id}/branches/{branch_id}/roles |
Postgres-Rollen ansehen |
| Rolle erstellen | POST |
/projects/{project_id}/branches/{branch_id}/roles |
Eine OAuth-Rolle erstellen | Eine Passwortrolle erstellen |
| Rolle abrufen | GET |
/projects/{project_id}/branches/{branch_id}/roles/{role_id} |
Postgres-Rollen ansehen |
| Rolle aktualisieren | PATCH |
/projects/{project_id}/branches/{branch_id}/roles/{role_id} |
Aktualisieren einer Rolle |
| Rolle löschen | DELETE |
/projects/{project_id}/branches/{branch_id}/roles/{role_id} |
Eine Rolle löschen |
Sicherungszeitplan
Ein Wurzelzweig hat einen einzigen Backup-Plan. Es sind nur „Get“ und „Update“ verfügbar. Durch die Aktualisierung werden alle Intervalle des Zeitplans ersetzt.
| Operation | Methode | Endpunkt | Dokumentation |
|---|---|---|---|
| Holen Sie sich einen Backup-Zeitplan | GET |
/projects/{project_id}/branches/{branch_id}/snapshot-schedule |
Erstellen Sie einen Backup-Zeitplan |
| Sicherungszeitplan aktualisieren | PATCH |
/projects/{project_id}/branches/{branch_id}/snapshot-schedule |
Erstellen Sie einen Backup-Zeitplan |
Hinweis
Das Update ist ein langwieriger Vorgang. Den zurückgegebenen Vorgang abfragen, bis done: true. Siehe Lang andauernde Vorgänge.
Kataloge
| Operation | Methode | Endpunkt | Dokumentation |
|---|---|---|---|
| Registriere die Datenbank mit dem Unity-Katalog | POST |
/catalogs |
Eine Datenbank registrieren |
| Katalogregistrierung erhalten | GET |
/catalogs/{catalog_id} |
Registrierungsstatus prüfen |
| Katalogregistrierung löschen | DELETE |
/catalogs/{catalog_id} |
Aufheben der Registrierung einer Datenbank |
Hinweis
Register- und Löschvorgänge sind lang andauernde Vorgänge. Den zurückgegebenen Vorgang abfragen, bis done: true. Siehe Lang andauernde Vorgänge.
Durch das Löschen einer Katalogregistrierung wird die zugrunde liegende Postgres-Datenbank nicht gelöscht.
Synchronisierte Tabellen
| Operation | Methode | Endpunkt | Dokumentation |
|---|---|---|---|
| Synchronisierungstabelle erstellen | POST |
/synced_tables |
Eine synchronisierte Tabelle erstellen |
| Synchronisierte Tabelle abrufen | GET |
/synced_tables/{table_name} |
Synchronisationsstatus prüfen |
| Synchronisierte Tabelle löschen | DELETE |
/synced_tables/{table_name} |
Lösche eine synchronisierte Tabelle |
Hinweis
Das table_name im Pfad verwendet das Format catalog.schema.table.
Das Erstellen und Löschen sind zeitaufwendige Vorgänge. Den zurückgegebenen Vorgang abfragen, bis done: true. Siehe Lang andauernde Vorgänge.
Durch das Löschen einer synchronisierten Tabelle wird nur die Unity-Katalogregistrierung entfernt. Legen Sie den Postgres-Tisch separat ab, um Platz freizugeben.
Change Data Feed
Die Lakebase Change Data Feed (CDF)-Operationen sind auf einen Zweig beschränkt. Für Details zur Anfrage und Antwort siehe die CDF-Operationen in der Postgres API-Referenz.
| Operation | Methode | Dokumentation |
|---|---|---|
| CDF-Konfiguration erstellen | POST |
Starte den Änderungsdatenfeed |
| Erhalten Sie den CDF-Status | GET |
Starte den Änderungsdatenfeed |
| CDF-Status auflisten | GET |
Starte den Änderungsdatenfeed |
| CDF-Konfiguration erhalten | GET |
Starte den Änderungsdatenfeed |
| CDF-Konfiguration löschen | DELETE |
Lakebase CDF deaktivieren |
Hinweis
Erstellen Sie eine CDF-Konfiguration, um einen Änderungsdatenfeed zu starten. Du kannst auch einen Feed über die Lakebase-Benutzeroberfläche starten. Siehe Den Änderungsdatenfeed starten.
Das Löschen einer CDF-Konfiguration entfernt dauerhaft die Konfiguration und ihre Tabellenzuordnungen; die Ziel-Delta-Tabellen im Unity-Katalog werden erhalten.
Datenbankzugangsdaten
| Operation | Methode | Endpunkt | Dokumentation |
|---|---|---|---|
| Datenbankanmeldeinformationen generieren | POST |
/credentials |
OAuth-Token-Authentifizierung |
Operationen
| Operation | Methode | Endpunkt | Dokumentation |
|---|---|---|---|
| Vorgang abrufen | GET |
/projects/{project_id}/operations/{operation_id} |
Siehe Beispiel unten |
Berechtigungen
Project ACL-Berechtigungen verwenden die standard Azure Databricks Permissions API und nicht den /api/2.0/postgres/ Basispfad. Legen Sie die request_object_type auf database-projects und request_object_id auf Ihre Projekt-ID fest (z. B. my-app).
| Operation | Methode | Endpunkt | Dokumentation |
|---|---|---|---|
| Abrufen von Projektberechtigungen | GET |
/api/2.0/permissions/database-projects/{project_id} |
Berechtigungs-API-Referenz |
| Aktualisieren von Projektberechtigungen | PATCH |
/api/2.0/permissions/database-projects/{project_id} |
Berechtigungs-API-Referenz |
| Ersetzen von Projektberechtigungen | PUT |
/api/2.0/permissions/database-projects/{project_id} |
Berechtigungs-API-Referenz |
Die zulässigen Berechtigungsstufen für Lakebase-Projekte sind CAN_USE und CAN_MANAGE.
CAN_CREATE ist ein vererbtes Level und kann nicht über die API gesetzt werden. Siehe Berechtigungsstufen.
Für Verwendungsbeispiele und entsprechende CLI/SDK/Terraform-Kommandos siehe Erteilen von Berechtigungen programmgesteuert.
Operation abrufen
Überprüfen Sie den Status eines lang andauernden Vorgangs anhand des Ressourcennamens.
Python SDK
from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Project, ProjectSpec
w = WorkspaceClient()
# Start an operation (example: create project)
operation = w.postgres.create_project(
project=Project(spec=ProjectSpec(pg_version=17)),
project_id="my-project",
)
print(f"Operation started: {operation.name()}")
# Wait for completion
result = operation.wait()
print(f"Operation completed: {result.name}")
Java SDK
import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;
WorkspaceClient w = new WorkspaceClient();
// Start an operation (example: create project)
CreateProjectOperation operation = w.postgres().createProject(
new CreateProjectRequest()
.setProjectId("my-project")
.setProject(new Project()
.setSpec(new ProjectSpec()
.setPgVersion(17L)))
);
System.out.println("Operation started: " + operation.getName());
// Wait for completion
Project result = operation.waitForCompletion();
System.out.println("Operation completed: " + result.getName());
Befehlszeilenschnittstelle (CLI)
Die CLI wartet automatisch, bis Vorgänge standardmäßig abgeschlossen sind. Verwenden Sie --no-wait zum Überspringen des Abfragens.
# Create project without waiting
databricks postgres create-project my-project --no-wait \
--json '{"spec": {"pg_version": 17}}'
# Later, check the operation status using the operation name from the response
databricks postgres get-operation projects/my-project/operations/<operation-id>
cURL
# Get operation status
curl -X GET "$WORKSPACE/api/2.0/postgres/projects/my-project/operations/<operation-id>" \
-H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq
Antwortformat:
{
"name": "projects/my-project/operations/<operation-id>",
"done": true,
"response": {
"@type": "type.googleapis.com/databricks.postgres.v1.Project",
"name": "projects/my-project",
...
}
}
Felder:
-
done:falsewährend der Arbeit,truewenn abgeschlossen -
response: Enthält das Ergebnis, wenndonetrueist -
error: Enthält Fehlerdetails, falls die Operation fehlgeschlagen ist
Allgemeine Muster
Ressourcen-Namensgebung
Ressourcen folgen einem hierarchischen Benennungsmuster, bei dem untergeordnete Ressourcen ihren übergeordneten Elementen zugeordnet sind.
Projekte verwenden dieses Format:
projects/{project_id}
Untergeordnete Ressourcen wie Vorgänge werden unter ihrem übergeordneten Projekt geschachtelt:
projects/{project_id}/operations/{operation_id}
Dies bedeutet, dass Sie die übergeordnete Projekt-ID für den Zugriff auf Vorgänge oder andere untergeordnete Ressourcen benötigen.
Ressourcen-IDs:
Beim Erstellen von Ressourcen müssen Sie eine Ressourcen-ID angeben (z. B. my-app) für die Parameter project_id, branch_id oder endpoint_id. Diese ID wird Teil des Ressourcenpfads in API-Aufrufen (z. B. projects/my-app/branches/development).
role_id und database_id API-Ressourcen identifizieren.
spec.postgres_role und spec.postgres_database bezeichnen die entsprechenden Postgres-Objekte.
Sie können optional ein display_name bereitstellen, um Ihrer Ressource eine aussagekräftige Beschriftung zu geben. Wenn Sie keinen Anzeigenamen angeben, verwendet das System Ihre Ressourcen-ID als Anzeigenamen.
Tip
Um ein Projekt in der Lakebase App zu finden, suchen Sie in der Projektliste nach seinem Anzeigenamen. Wenn Sie beim Erstellen des Projekts keinen benutzerdefinierten Anzeigenamen angegeben haben, suchen Sie nach Ihrem project_id (z. B. "my-app").
Hinweis
Ressourcen-IDs können nach der Erstellung nicht mehr geändert werden.
Requirements:
- Muss 1 bis 63 Zeichen lang sein
- Nur Kleinbuchstaben, Ziffern und Bindestriche
- Kann nicht mit einem Bindestrich beginnen oder enden
- Beispiele:
my-app, ,analytics-dbcustomer-123
Langlaufende Operationen (LROs)
Erstellen, Aktualisieren und Löschen geben ein databricks.longrunning.Operation Objekt zurück, das einen Abschlussstatus bereitstellt.
Antwort auf Beispielvorgang:
{
"name": "projects/my-project/operations/<operation-id>",
"done": false
}
Auf Abschluss prüfen mit GetOperation:
Python SDK
from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Project, ProjectSpec
w = WorkspaceClient()
# Start an operation
operation = w.postgres.create_project(
project=Project(spec=ProjectSpec(pg_version=17)),
project_id="my-project",
)
# Wait for completion
result = operation.wait()
print(f"Operation completed: {result.name}")
Java SDK
import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;
WorkspaceClient w = new WorkspaceClient();
// Start an operation
CreateProjectOperation operation = w.postgres().createProject(
new CreateProjectRequest()
.setProjectId("my-project")
.setProject(new Project()
.setSpec(new ProjectSpec()
.setPgVersion(17L)))
);
// Wait for completion
Project result = operation.waitForCompletion();
System.out.println("Operation completed: " + result.getName());
Befehlszeilenschnittstelle (CLI)
Die CLI wartet automatisch, bis Vorgänge standardmäßig abgeschlossen sind. Verwenden Sie --no-wait, um sofort zurückzukehren:
databricks postgres create-project my-project --no-wait \
--json '{"spec": {"pg_version": 17}}'
cURL
# Poll the operation
curl "$WORKSPACE/api/2.0/postgres/projects/my-project/operations/<operation-id>" \
-H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq '.done'
Alle paar Sekunden abfragen, bis donetrue ist.
Aktualisieren von Masken
Aktualisierungsvorgänge erfordern einen update_mask Parameter, der angibt, welche Felder geändert werden sollen. Dadurch wird verhindert, dass nicht verknüpfte Felder versehentlich überschrieben werden.
Formatunterschiede:
| Methode | Format | Example |
|---|---|---|
| REST API | Query parameter (Abfrageparameter) | ?update_mask=spec.display_name |
| Python SDK | FieldMask-Objekt | update_mask=FieldMask(field_mask=["spec.display_name"]) |
| Befehlszeilenschnittstelle (CLI) | Positionsargument | update-project NAME spec.display_name |
Fehlerbehandlung
Die Lakebase-API gibt standardmäßige HTTP-Statuscodes zurück.
409: Widersprüchliche Operationen
Lakebase kann aus mehreren Gründen einen 409 Conflict Fehler zurückgeben:
- Ein interner Wartungsvorgang wird im Projekt ausgeführt.
- Das Projekt hat seine Kapazitätsgrenze für gleichzeitige Vorgänge erreicht.
- Ihre eigenen API-Anforderungen überlappen sich. Zum Beispiel das Erstellen einer Verzweigung, bevor eine vorherige Verzweigungserstellung abgeschlossen ist.
Was es bedeutet:
Lakebase plant manchmal Wartungsvorgänge für Projekte. Wenn eine Clientanforderung eingeht, während eine dieser Vorgänge ausgeführt wird, lehnt Lakebase die neue Anforderung mit einem 409 Conflict Fehler ab. Sie erhalten möglicherweise auch diese Antwort, wenn das Projekt ausgelastet ist oder sich Ihre API-Aufrufe überlappen.
Dieses Verhalten wird erwartet. Clients sollten darauf vorbereitet sein, Anforderungen erneut auszuführen, wenn dieser Fehler auftritt.
Was zu tun ist:
Wiederholen Sie die Anforderung. Wenn der interne Vorgang abgeschlossen oder Kapazität freigegeben wird, akzeptiert Lakebase neue Anforderungen für das Projekt.
Verwenden Sie eine exponentielle Backoff-Strategie für Wiederholungen: Warten Sie ein kurzes Intervall, bevor Sie den ersten Wiederholungsversuch ausführen, und verdoppeln Sie dann die Wartezeit bei jedem nachfolgenden Versuch. Ein Startintervall von 100 Millisekunden mit maximal 30 Sekunden ist ein vernünftiger Standardwert.
Python SDK
import time
from databricks.sdk import WorkspaceClient
from databricks.sdk.errors import ResourceConflict
from databricks.sdk.service.postgres import Branch, BranchSpec
w = WorkspaceClient()
def retry_on_conflict(fn, max_attempts=5, base_delay=0.1):
"""Retry a Lakebase API call when a conflicting operation is in progress."""
for attempt in range(max_attempts):
try:
return fn()
except ResourceConflict:
if attempt == max_attempts - 1:
raise
wait = base_delay * (2 ** attempt)
print(f"Conflicting operation in progress. Retrying in {wait}s...")
time.sleep(wait)
# Example: create a branch with retry
branch = retry_on_conflict(
lambda: w.postgres.create_branch(
parent="projects/my-project",
branch=Branch(spec=BranchSpec(no_expiry=True)),
branch_id="my-branch",
).wait()
)
cURL
# Retry with exponential backoff on 409 responses
retry_on_conflict() {
local cmd=("$@")
local max_attempts=5
local delay=0.1
local attempt=0
while [ $attempt -lt $max_attempts ]; do
response=$(curl -s -w "\n%{http_code}" "${cmd[@]}")
http_code=$(echo "$response" | tail -n1)
body=$(echo "$response" | sed '$d')
if [ "$http_code" -ne 409 ]; then
echo "$body"
return 0
fi
attempt=$((attempt + 1))
if [ $attempt -eq $max_attempts ]; then
echo "Max retries reached. Last response: $body" >&2
return 1
fi
echo "Conflicting operation in progress. Retrying in ${delay}s..." >&2
sleep "$delay"
delay=$((delay * 2))
done
}
# Example: create a branch with retry
retry_on_conflict \
-X POST "$WORKSPACE/api/2.0/postgres/projects/my-project/branches?branch_id=my-branch" \
-H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
-H "Content-Type: application/json" \
-d '{"spec": {"no_expiry": true}}'
Hinweis
Ein 409 Conflict in einer Lakebase API-Anfrage bedeutet, dass die Anfrage nicht akzeptiert wurde, nicht, dass sie angewendet wurde. Überprüfen Sie immer den Ressourcenstatus nach einem erfolgreichen Wiederholungsversuche, indem Sie den entsprechenden GET Endpunkt aufrufen.