Przewodnik po API Lakebase

Ta strona przedstawia przegląd API Lakebase, w tym uwierzytelnianie, dostępne punkty końcowe oraz typowe wzorce pracy z API REST, Databricks CLI oraz SDK Databricks (Python, Java, Go).

Pełną listę operacji i ich parametrów można znaleźć w odniesieniu do API Postgres.

Uwaga / Notatka

Niektóre operacje pozostają w fazie beta. Referencja API Postgres oznacza status każdej operacji.

Authentication

API Lakebase wykorzystuje uwierzytelnianie OAuth na poziomie przestrzeni roboczej do zarządzania infrastrukturą projektu (tworzenie projektów, konfigurowanie ustawień itp.).

Uwaga / Notatka

Dwa typy łączności: API służy do zarządzania platformą (tworzenie projektów, gałęzi, zasobów obliczeniowych). Aby uzyskać dostęp do bazy danych (nawiązywanie połączenia z danymi):

  • Klienci SQL (psql, pgAdmin, DBeaver): Używaj tokenów Lakebase OAuth lub haseł Postgres. Zobacz Uwierzytelnianie.
  • Data API (RESTful HTTP): Używaj tokenów Lakebase OAuth. Zobacz Interfejs API danych.
  • Sterowniki języków programowania (psycopg, SQLAlchemy, JDBC): Używaj tokenów Lakebase OAuth lub haseł Postgres. Zobacz Szybki start.

Aby uzyskać pełne wyjaśnienie tych dwóch warstw uwierzytelniania, zobacz Architektura uwierzytelniania.

Ustaw uwierzytelnianie

Uwierzytelnianie przy użyciu interfejsu wiersza polecenia usługi Databricks:

databricks auth login --host https://your-workspace.cloud.databricks.com

Postępuj zgodnie z monitami przeglądarki, aby się zalogować. Interfejs wiersza polecenia buforuje token OAuth pod adresem ~/.databricks/token-cache.json.

Następnie wybierz metodę dostępu:

zestaw SDK Python

Zestaw SDK używa ujednoliconego uwierzytelniania i automatycznie obsługuje tokeny OAuth:

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

zestaw SDK Java

Zestaw SDK używa ujednoliconego uwierzytelniania i automatycznie obsługuje tokeny OAuth:

import com.databricks.sdk.WorkspaceClient;

WorkspaceClient w = new WorkspaceClient();

CLI

Polecenia automatycznie używają buforowanego tokenu:

databricks postgres list-projects

skręt

Wygeneruj token i ustaw URL przestrzeni roboczej dla bezpośrednich wywołań API. Przykłady curlów w dokumentacji Lakebase zakładają następujące dwie zmienne środowiskowe:

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

Tokeny OAuth wygasają po godzinie. W razie potrzeby wygeneruj ponownie.

Aby uzyskać więcej informacji, zobacz Autoryzowanie dostępu użytkowników do usługi Databricks przy użyciu protokołu OAuth.

Dostępne punkty końcowe

API Postgres używa bazowej ścieżki /api/2.0/postgres/. Polityki obliczeniowe i uprawnienia zasobów korzystają z oddzielnych ścieżek API.

Polityki obliczeń bezserwerowych

Important

W przestrzeniach roboczych zarejestrowanych w polityce obliczeń bezserwerowych Private Preview:

  • Tworzenie projektu Lakebase wymaga uprawnienia CAN_USE lub CAN_MANAGE w polityce, która zezwala na Lakebase.
  • Zmiana mocy obliczeniowej lub ustawień skalowania do zera wymaga CAN_MANAGE projektu Lakebase i CAN_USE /lub CAN_MANAGE jego polityki. Dotyczy to nawet sytuacji, gdy zasada nie ustala limitu dla tego ustawienia.
  • Zmiana wyświetlanej nazwy projektu Lakebase wymaga tylko CAN_MANAGE w projekcie Lakebase.
  • Zastąpienie zasady wymaga uprawnienia CAN_MANAGE w projekcie Lakebase oraz CAN_USE lub CAN_MANAGE w obu zasadach. Wyczyszczenie spec.compute_policy_id powoduje przypisanie domyślnej polityki Lakebase jako polityki zastępczej.

Zaktualizowane ustawienia muszą spełniać obecne ograniczenia polityki i zachować wymagane pary klucz-wartość tagów. Zobacz Uprawnienia do zmian konfiguracji.

Aby poprosić o dostęp do wersji zapoznawczej, skontaktuj się z zespołem konta Databricks.

Polityki mogą ograniczać pojemność obliczeniową i czas bezczynności przed skalowaniem do zera oraz wymuszać tagi. Zarządzanie politykami jest dostępne wyłącznie przez API i wykorzystuje /api/2.0/policies/compute.

Ustaw spec.compute_policy_id podczas tworzenia projektu Lakebase, aby wybrać politykę obliczeń. Aby poznać zarządzanie politykami i uprawnieniami, zobacz Zarządzanie politykami obliczeń bezserwerowych. Przykłady API Postgres dotyczące operacji projektów Lakebase i aktualizacji obliczeniowych znajdziesz w sekcji Używanie polityki z projektami Lakebase. Oddzielne spec.budget_policy_id pole wybiera zasady użycia środowiska serverless do atrybucji kosztów.

Aby zmienić załączoną politykę, zobacz Zastąp politykę projektu Lakebase.

Projekty

Operation Metoda Endpoint Dokumentacja
Tworzenie projektu POST /projects Stwórz projekt
Aktualizowanie projektu PATCH /projects/{project_id} Ogólne ustawienia
Usuwanie projektu DELETE /projects/{project_id} Usuń projekt
Pobierz projekt GET /projects/{project_id} Uzyskaj szczegóły projektu
Lista projektów GET /projects Wyświetl projekty

Oddziały

Operation Metoda Endpoint Dokumentacja
Utworzyć odgałęzienie POST /projects/{project_id}/branches Utwórz gałąź
Aktualizuj gałąź PATCH /projects/{project_id}/branches/{branch_id} Zaktualizuj ustawienia gałęzi
Usuń gałąź DELETE /projects/{project_id}/branches/{branch_id} Usuń gałąź
Pobieranie gałęzi GET /projects/{project_id}/branches/{branch_id} Zobacz gałęzie
Wyświetl gałęzie GET /projects/{project_id}/branches Wyświetl gałęzie

Migawki

Operation Metoda Endpoint Dokumentacja
Utwórz migawkę POST /projects/{project_id}/snapshots Stwórz migawkę
Usuń migawkę DELETE /projects/{project_id}/snapshots/{snapshot_id} Usuń migawkę
Pobierz migawkę GET /projects/{project_id}/snapshots/{snapshot_id} Pobierz i wypisz migawki
Wylistuj migawki GET /projects/{project_id}/snapshots Pobierz i wypisz migawki
Przywróć migawkę (utwórz gałąź z migawki) POST /projects/{project_id}/branches Przywracaj z migawki

Endpointy (instancje obliczeniowe i repliki do odczytu)

W interfejsie API obliczenia są nazywane punktem końcowym. Aby zapoznać się z omówieniem pojęć, zobacz Obliczenia i punkty końcowe.

W poniższej tabeli przedstawiono mapowanie pojęć interfejsu użytkownika na ich odpowiedniki w API:

Koncepcja interfejsu użytkownika Zasób lub pole interfejsu API Dokumentacja
Podstawowe obliczenia Punkt końcowy z endpoint_type: ENDPOINT_TYPE_READ_WRITE Zarządzaj obliczeniami
Replika do odczytu Punkt końcowy z endpoint_type: ENDPOINT_TYPE_READ_ONLY Zarządzaj replikami odczytu
Wysoka dostępność group pole (EndpointGroupSpec) na specyfikacji końcowej Zarządzaj wysoką dostępnością
Identyfikatory obliczeniowe (UID, Nazwa zasobu) uid oraz name (pełna ścieżka zasobu) na obiekcie Endpoint Identyfikatory Compute

Dostępne operacje

Operation Metoda Endpoint Dokumentacja
Tworzenie punktu końcowego POST /projects/{project_id}/branches/{branch_id}/endpoints Stwórz replikę odczytu
Aktualizowanie punktu końcowego PATCH /projects/{project_id}/branches/{branch_id}/endpoints/{endpoint_id} Edytuj compute / Edytuj replikę do odczytu / Zarządzaj wysoką dostępnością
Usuń punkt końcowy DELETE /projects/{project_id}/branches/{branch_id}/endpoints/{endpoint_id} Usuń replikę odczytu
Pobierz punkt końcowy GET /projects/{project_id}/branches/{branch_id}/endpoints/{endpoint_id} Zobacz zasoby obliczeniowe
Wymień punkty końcowe GET /projects/{project_id}/branches/{branch_id}/endpoints Zobacz zasoby obliczeniowe

Endpointów odczytu i zapisu nie można usuwać bezpośrednio. Usuń gałąź nadrzędną, aby je usunąć. Aby uniknąć kosztów obliczeniowych przy zachowaniu rozgałęzienia, ustaw spec.disabled na true. Zobacz Wyłącz lub włącz obliczenia.

Role

Operation Metoda Endpoint Dokumentacja
Wyświetlanie listy ról GET /projects/{project_id}/branches/{branch_id}/roles Zobacz role Postgresa
Tworzenie roli POST /projects/{project_id}/branches/{branch_id}/roles | Stwórz rolę hasła
Pobierz rolę GET /projects/{project_id}/branches/{branch_id}/roles/{role_id} Zobacz role Postgresa
Aktualizowanie roli PATCH /projects/{project_id}/branches/{branch_id}/roles/{role_id} Zaktualizuj rolę
Usuwanie roli DELETE /projects/{project_id}/branches/{branch_id}/roles/{role_id} Usuń rolę

Harmonogram kopii zapasowych

Gałąź główna ma pojedynczy harmonogram kopii zapasowej. Dostępne są tylko opcje pobierania i aktualizacji. Aktualizacja zastępuje pełny zestaw rytmów w harmonogramie.

Operation Metoda Endpoint Dokumentacja
Uzyskaj zapasowy harmonogram GET /projects/{project_id}/branches/{branch_id}/snapshot-schedule Stwórz harmonogram kopii zapasowej
Aktualizuj harmonogram kopii zapasowych PATCH /projects/{project_id}/branches/{branch_id}/snapshot-schedule Stwórz harmonogram kopii zapasowej

Uwaga / Notatka

Aktualizacja to długotrwała operacja. Monitoruj zwróconą operację do chwili done: true. Zobacz Długotrwałe operacje.

Katalogi

Operation Metoda Endpoint Dokumentacja
Zarejestruj bazę danych w katalogu Unity POST /catalogs Zarejestruj bazę danych
Pobierz rejestrację katalogu GET /catalogs/{catalog_id} Sprawdź status rejestracji
Usuń rejestrację katalogu DELETE /catalogs/{catalog_id} Wyrejestruj bazę danych

Uwaga / Notatka

Rejestrowanie i usuwanie to długotrwałe operacje. Monitoruj zwróconą operację do chwili done: true. Zobacz Długotrwałe operacje.

Usunięcie rejestracji katalogu nie powoduje usunięcia bazowej bazy danych Postgres.

Zsynchronizowane tabele

Operation Metoda Endpoint Dokumentacja
Tworzenie zsynchronizowanej tabeli POST /synced_tables Stwórz zsynchronizowaną tabelę
Pobieranie zsynchronizowanej tabeli GET /synced_tables/{table_name} Sprawdź status synchronizacji
Usuwanie zsynchronizowanej tabeli DELETE /synced_tables/{table_name} Usuń zsynchronizowaną tabelę

Uwaga / Notatka

Element table_name w ścieżce używa formatu catalog.schema.table.

Operacje tworzenia i usuwania są długotrwałe. Monitoruj zwróconą operację do chwili done: true. Zobacz Długotrwałe operacje.

Usunięcie zsynchronizowanej tabeli powoduje usunięcie rejestracji w katalogu Unity Catalog. Usuń tabelę Postgres oddzielnie, aby zwolnić miejsce.

Strumień zmian danych

Operacje Lakebase Change Data Feed (CDF) są ograniczone do gałęzi. Szczegółowe informacje o żądaniach i odpowiedziach znajdziesz w sekcji operacji CDF w dokumentacji API Postgres.

Operation Metoda Dokumentacja
Utwórz konfigurację CDF POST Uruchom Change Data Feed
Uzyskaj status CDF GET Uruchom Change Data Feed
Lista statusów CDF GET Uruchom Change Data Feed
Pobierz konfigurację CDF GET Uruchom Change Data Feed
Usuń konfigurację CDF DELETE Wyłącz Lakebase CDF

Uwaga / Notatka

Stwórz konfigurację CDF do uruchomienia przepływu danych zmian. Możesz też uruchomić transmisję z interfejsu Lakebase. Zobacz Uruchamianie źródła danych zmian.

Usunięcie konfiguracji CDF trwale usuwa konfigurację i jej mapowania tabel; docelowe tabele Delta w Unity Catalog pozostają zachowane.

Poświadczenia do bazy danych

Operation Metoda Endpoint Dokumentacja
Generowanie poświadczeń bazy danych POST /credentials Uwierzytelnianie tokenów OAuth

Operacje

Operation Metoda Endpoint Dokumentacja
Operacja pobierania GET /projects/{project_id}/operations/{operation_id} Zobacz przykład poniżej

Uprawnienia

Uprawnienia listy ACL projektu używają standardowego interfejsu API uprawnień Azure Databricks, a nie ścieżki podstawowej /api/2.0/postgres/. Ustaw request_object_type na database-projects i request_object_id na identyfikator projektu (na przykład my-app).

Operation Metoda Endpoint Dokumentacja
Uzyskiwanie uprawnień projektu GET /api/2.0/permissions/database-projects/{project_id} Dokumentacja API uprawnień
Aktualizowanie uprawnień projektu PATCH /api/2.0/permissions/database-projects/{project_id} Dokumentacja API uprawnień
Zastąp uprawnienia projektu PUT /api/2.0/permissions/database-projects/{project_id} Dokumentacja API uprawnień

Poziomy uprawnień możliwych do udzielenia dla projektów Lakebase to CAN_USE i CAN_MANAGE. CAN_CREATE jest poziomem dziedziczonym i nie może być ustawiony przez API. Zobacz Poziomy uprawnień.

Przykłady użycia i odpowiedniki interfejsu wiersza polecenia/zestawu SDK/narzędzia Terraform można znaleźć w temacie Programowe udzielanie uprawnień.

Pobierz operację

Sprawdź stan długotrwałej operacji według nazwy zasobu.

zestaw SDK Python

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

zestaw SDK Java

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

CLI

Interfejs wiersza polecenia automatycznie czeka na ukończenie operacji domyślnie. Użyj polecenia --no-wait , aby pominąć sondowanie:

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

skręt

# Get operation status
curl -X GET "$WORKSPACE/api/2.0/postgres/projects/my-project/operations/<operation-id>" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Format odpowiedzi:

{
  "name": "projects/my-project/operations/<operation-id>",
  "done": true,
  "response": {
    "@type": "type.googleapis.com/databricks.postgres.v1.Project",
    "name": "projects/my-project",
    ...
  }
}

Pola:

  • done: false podczas trwania pracy, true gdy jest ukończona
  • response: Zawiera wynik, gdy done jest true
  • error: Zawiera szczegóły błędu, jeśli operacja się nie powiodła

Często używane wzorce

Nazewnictwo zasobów

Zasoby są zgodne ze wzorcem nazewnictwa hierarchicznego, w którym zasoby podrzędne są ograniczone do ich elementu nadrzędnego.

Projekty używają tego formatu:

projects/{project_id}

Zasoby podrzędne, takie jak operacje, są zagnieżdżone w ramach projektu nadrzędnego.

projects/{project_id}/operations/{operation_id}

Oznacza to, że potrzebujesz identyfikatora projektu nadrzędnego, aby uzyskać dostęp do operacji lub innych zasobów podrzędnych.

Identyfikatory zasobów:

Podczas tworzenia zasobów należy podać identyfikator zasobu (na przykład my-app) dla parametru project_id, branch_idlub endpoint_id . Ten identyfikator staje się częścią ścieżki zasobu w wywołaniach interfejsu API (takich jak projects/my-app/branches/development).

role_id i database_id identyfikują zasoby API. spec.postgres_role i spec.postgres_database nazywają odpowiadające im obiekty Postgres.

Opcjonalnie możesz podać element , display_name aby nadać zasobowi bardziej opisową etykietę. Jeśli nie określisz nazwy wyświetlanej, system używa identyfikatora zasobu jako nazwy wyświetlanej.

Wskazówka

Aby znaleźć projekt w aplikacji Lakebase, poszukaj jego nazwy wyświetlanej na liście projektów. Jeśli podczas tworzenia projektu nie ustanowisz własnej nazwy wyświetlanej, wyszukaj nazwę project_id (np. "my-app").

Uwaga / Notatka

Nie można zmienić identyfikatorów zasobów po utworzeniu.

Wymagania:

  • Musi mieć długość od 1 do 63 znaków
  • Małe litery, cyfry i łączniki tylko
  • Nie można zaczynać ani kończyć myślnikiem
  • Przykłady: my-app, , analytics-dbcustomer-123

Długotrwałe operacje (LRO)

Operacje tworzenia, aktualizowania i usuwania zwracają databricks.longrunning.Operation obiekt, który zapewnia stan ukończenia.

Przykładowa odpowiedź operacji:

{
  "name": "projects/my-project/operations/<operation-id>",
  "done": false
}

Sprawdzaj status zakończenia za pomocą GetOperation:

zestaw SDK Python

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

zestaw SDK Java

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

CLI

Interfejs wiersza polecenia automatycznie czeka na ukończenie operacji domyślnie. Użyj polecenia --no-wait , aby natychmiast zwrócić:

databricks postgres create-project my-project --no-wait \
  --json '{"spec": {"pg_version": 17}}'

skręt

# Poll the operation
curl "$WORKSPACE/api/2.0/postgres/projects/my-project/operations/<operation-id>" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq '.done'

Sonduj co kilka sekund, aż done stanie się true.

Aktualizuj maski

Operacje aktualizacji wymagają parametru update_mask określającego pola do zmodyfikowania. Zapobiega to przypadkowemu zastępowaniu niepowiązanych pól.

Różnice w formacie:

Metoda Format Example
interfejs API REST Parametr zapytania ?update_mask=spec.display_name
zestaw SDK Python Obiekt FieldMask update_mask=FieldMask(field_mask=["spec.display_name"])
CLI Argument pozycyjny update-project NAME spec.display_name

Obsługa błędów

Interfejs API usługi Lakebase zwraca standardowe kody stanu HTTP.

409: Konflikty w operacjach

Usługa Lakebase może z kilku powodów zwrócić błąd 409 Conflict.

  • Operacja konserwacji wewnętrznej jest w toku w projekcie.
  • Projekt osiągnął limit operacji współbieżnych.
  • Twoje własne żądania interfejsu API nakładają się na siebie. Na przykład utworzenie gałęzi przed zakończeniem tworzenia poprzedniej gałęzi.

Co to oznacza:

Lakebase czasami planuje operacje konserwacyjne w projektach. Jeśli żądanie klienta zostanie odebrane, gdy jedna z tych operacji jest w toku, usługa Lakebase odrzuca nowe żądanie z błędem 409 Conflict . Możesz również uzyskać taką odpowiedź, gdy projekt osiągnął swoją pojemność lub wywołania interfejsu API zachodzą na siebie.

Jest to oczekiwane zachowanie. Klienci powinni być przygotowani do ponawiania żądań po wystąpieniu tego błędu.

Co robić:

Spróbuj ponownie wysłać żądanie. Po zakończeniu operacji wewnętrznej lub zwolnieniu się zasobów, Lakebase akceptuje nowe żądania dla projektu.

Użyj wycofywania wykładniczego dla ponownych prób: poczekaj krótki interwał przed pierwszą ponowną próbą, a następnie dwukrotnie zaczekaj na każdą kolejną próbę. Interwał początkowy wynoszący 100 milisekund z maksymalnie 30 sekundami jest rozsądnym ustawieniem domyślnym.

zestaw SDK Python
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()
)
skręt
# 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}}'

Uwaga / Notatka

Element 409 Conflict w żądaniu interfejsu API usługi Lakebase oznacza, że żądanie nie zostało zaakceptowane, a nie zastosowane. Zawsze sprawdź stan zasobu po pomyślnym ponowieniu próby, wywołując odpowiedni GET punkt końcowy.

SDK-i i infrastructure-as-code