Zarządzaj zasadami obliczeń bezserwerowych

Polityki obliczeń bezserwerowych pozwalają administratorom przestrzeni roboczej kontrolować dostęp do obsługiwanych produktów obliczeniowych bezserwerowych, ograniczać ich konfigurację oraz wymuszać tagi na nowo utworzonych zasobach obliczeniowych. Ta strona wyjaśnia, jak tworzyć polityki, przyznawać dostęp i korzystać z nich z Lakebase.

Important

Polityki obliczeń bezserwerowych znajdują się w trybie Private Preview i są zarządzane przez REST API. Podgląd obsługuje Lakebase. Skontaktuj się z zespołem konta usługi Databricks, aby zażądać dostępu.

Requirements

  • Twoje środowisko robocze musi być zarejestrowane w podglądzie polityki obliczeń bezserwerowych i mieć dostęp do Lakebase. Zobacz dostępność regionu dla dostępności regionu Lakebase.
  • Aby utworzyć politykę, musisz być administratorem przestrzeni roboczej. Aby przeczytać lub korzystać z istniejącej polisy, CAN_USE musisz być na niej zapisany CAN_MANAGE . Aby zaktualizować lub usunąć niestandardową politykę albo zarządzać uprawnieniami polityki, potrzebujesz CAN_MANAGE.
  • Przykłady używają curl, jq, oraz tokena OAuth w przestrzeni roboczej. Przykład uwierzytelniania używa Databricks CLI.

Jak działają zasady obliczeń bezserwerowych

Zasada obliczeń bezserwerowych należy do przestrzeni roboczej. Jego obiekt określa, allowed_compute_products z jakich produktów obliczeniowych użytkownik może korzystać w ramach polityki oraz jakie są limity konfiguracji każdego produktu. Udziel dostępu do polityki, aby użytkownicy mogli korzystać z produktów, na które polityka zezwala w ramach tych limitów.

Po utworzeniu dołączona polityka reguluje zmiany konfiguracją zasobu compute podczas jej obowiązywania. Zaostrzenie polityki nie zmienia istniejącego zasobu obliczeniowego. Kolejne aktualizacje ustawień regulowanych przez politykę muszą spełniać jej obecne ograniczenia. Na przykład zmiana pojemności Lakebase musi mieścić się w aktualnym maksymalne poziomie polityki, mierzonym w jednostkach obliczeniowych (CU).

Informacje o zasadach kontrolujących klasyczne zasoby obliczeniowe znajdziesz w artykule Tworzenie i zarządzanie zasadami klasycznych zasobów obliczeniowych.

Uprawnienia do zmian konfiguracji

Aktualizacja ustawień zasobu lub wymiana jego polityki obliczeniowej wymaga następujących uprawnień:

Zmiana konfiguracji Wymagane uprawnienia
Zmień ustawienia poza zakresem polityki Uprawnienie do zarządzania zasobem. Nie jest wymagane uprawnienie do korzystania z polityki.
Zmień ustawienia obliczeń regulowane przez politykę Uprawnienia do zarządzania zasobem i CAN_USE i/lub CAN_MANAGE w zasadach, nawet jeśli nie ustawia ona limitu dla ustawienia.
Zamień dołączoną politykę Uprawnienia do zarządzania zasobem oraz CAN_USE lub CAN_MANAGE zarówno do bieżącej polityki, jak i jej zamiennika.

Uprawnienia do zarządzania zasobem zależą od produktu. Na przykład użytkownik z uprawnieniem CAN_MANAGE w projekcie Lakebase może zmienić jego nazwę wyświetlaną bez dostępu do jego polityki obliczeniowej. Zmiana mocy obliczeniowej lub ustawień skalowania do zera wymaga uprawnień do korzystania z polityki, nawet jeśli polityka nie ustawia ograniczeń mocy ani czasu bezczynności.

Uprawnienie do korzystania z polityki nie omija jej ograniczeń. Zaktualizowane ustawienia muszą spełniać limity polityki i zachować wymagane pary klucz-wartość tagów.

Nie można usunąć polityki z zasobu bez przypisania jej zastępstwa. W przypadku projektu Lakebase zasada zastępcza musi zezwalać na Lakebase. Czyszczenie spec.compute_policy_id przypisuje Domyślną Politykę Lakebase jako jej zastępstwo i wymaga tych samych uprawnień.

Tagi polityki

Użyj opcjonalnej mapy najwyższego poziomu tags , aby określić tagi klucz-wartość obok display_name i allowed_compute_products. Klucze i wartości tagów są ciągami znaków. Polityka może mieć do 20 tagów, a każdy klucz musi być niepusty.

Tagi z polityki bezserwerowych zasobów obliczeniowych propagują się do zasobów obliczeniowych utworzonych za pomocą tej polityki. Polityka egzekwuje te tagi, dopóki polityka istnieje i pozostaje dołączona. Zmiany w tagach zasobu obliczeniowego muszą zachować pary klucz-wartość wymagane przez dołączoną politykę.

Polityki użytkowania bezserwerowego, zwane także politykami budżetu bezserwerowego, przypisują tagi do atrybucji kosztów i używają osobnego identyfikatora polityki. Możesz używać polityki użycia bezserwerowego razem z polityką obliczeń bezserwerowych. Utworzony zasób obliczeniowy otrzymuje sumę tagów obu polityk. Na przykład, jeśli polityka obliczeń określa environment=development, a polityka użycia określa cost_center=engineering, zasób obliczeniowy otrzymuje oba tagi.

Ustawienia zasad Lakebase

Aby zezwolić na Lakebase poprzez politykę obliczeń bezserwerowych, uwzględnij lakebase w allowed_compute_products.

Tworzenie projektu Lakebase

Utworzenie projektu Lakebase wymaga uprawnienia CAN_USE lub CAN_MANAGE w zasadach zezwalających na Lakebase. Gdy tworzysz projekt Lakebase, automatycznie otrzymujesz CAN_MANAGE do niego.

Uprawnienia zasad nie przyznają dostępu do istniejących projektów Lakebase ani ich danych. Uprawnienia projektów Lakebase kontrolują zarządzanie zasobami, przy czym dodatkowe uprawnienia zasad są wymagane do zmiany ustawień obliczeniowych regulowanych przez politykę. Role i uprawnienia w Postgres kontrolują dostęp do bazy danych.

Limity przepustowości i czasu bezczynności

Ustaw jedno lub oba z poniższych pól w allowed_compute_products.lakebase:

Pole Description
max_capacity_units_per_instance Maksymalna wydajność w Lakebase CU. Dla obliczeń z automatycznym skalowaniem skonfigurowane maksimum musi mieścić się w tym limicie.
max_idle_minutes_before_scale_to_zero Maksymalny limit bezczynności w minutach, zanim jednostka obliczeniowa skaluje się do zera. Jednostka obliczeniowa podlegająca temu limitowi musi mieć włączone skalowanie do zera, z limitem czasu na poziomie lub poniżej limitu.

Oba pola akceptują liczby całkowite dodatnie. Pominięcie pola nie ustawia limitu polityki dla tego ustawienia. Pusty obiekt lakebase pozwala na Lakebase bez żadnego z tych dwóch limitów. Polityka musi zawierać lakebase obiekt umożliwiający korzystanie z Lakebase.

Na przykład następujący lakebase obiekt ogranicza każde obliczenie do 16 CU i wymaga skalowania do zera po maksymalnie 15 minutach bezczynności:

{
  "max_capacity_units_per_instance": 16,
  "max_idle_minutes_before_scale_to_zero": 15
}

Te limity uzupełniają obsługiwane rozmiary obliczeń oraz ustawienia skalowalne do zera. Zasada nie sprawia, że nieobsługiwana konfiguracja staje się dostępna. Zobacz Ograniczenia dla konfiguracji, które nie mogą używać skalowania do zera.

Domyślna polityka Lakebase

Domyślna polityka Lakebase przestrzeni roboczej pozwala na korzystanie z Lakebase bez ograniczeń pojemności lub limitów czasu bezczynności. Użytkownicy Workspace mogą domyślnie tworzyć projekty Lakebase dzięki tej polityce.

Administratorzy przestrzeni roboczej mogą przyznawać lub cofać uprawnienia do domyślnej polityki Lakebase za pomocą API Uprawnień. Nie mogą usunąć polityki ani zmienić jej nazwy czy konfiguracji.

Gdy tworzysz projekt Lakebase bez określania polityki obliczeniowej, żądanie używa Domyślnej polityki Lakebase. Musisz mieć pozwolenie na korzystanie z tej polityki. Utworzenie niestandardowej polityki nie cofa dostępu do domyślnej polityki ani nie stosuje automatycznie niestandardowej polityki do istniejących projektów Lakebase. Aby wymagać od użytkowników wyboru niestandardowej polityki, zobacz Wymagaj niestandardowej polityki do tworzenia projektów Lakebase.

Skonfiguruj uwierzytelnianie API

Użyj adresu URL swojej przestrzeni roboczej oraz tokena OAuth przestrzeni roboczej dla tych żądań. Zobacz Autoryzacja dostępu użytkowników do Azure Databricks za pomocą OAuth, aby poznać szczegóły uwierzytelniania.

  1. Ustaw WORKSPACE na adres URL swojej przestrzeni roboczej, bez końcowego ukośnika:

    export WORKSPACE="https://<workspace-host>"
    
  2. Uwierzytelnij się w tym obszarze roboczym:

    databricks auth login --host "$WORKSPACE"
    
  3. Pobierz token OAuth dla uwierzytelnionej tożsamości:

    export DATABRICKS_TOKEN="$(databricks auth token --host "$WORKSPACE" | jq -r .access_token)"
    

Odśwież token, jeśli wygaśnie. Uruchom każde żądanie jako tożsamość z wymaganymi uprawnieniami.

Utwórz politykę

Poniższy przykład tworzy zasadę obliczeń bezserwerowych, która umożliwia korzystanie z Lakebase:

  1. Jako administrator przestrzeni roboczej wyślij następujące żądanie. Tworzy politykę z maksymalnym limitem 16 CU, maksymalnym limitem bezczynności 15 minut oraz wymuszonym environment=development tagiem:

    curl --fail-with-body -sS -X POST "$WORKSPACE/api/2.0/policies/compute" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{
        "display_name": "Lakebase development",
        "allowed_compute_products": {
          "lakebase": {
            "max_capacity_units_per_instance": 16,
            "max_idle_minutes_before_scale_to_zero": 15
          }
        },
        "tags": {
          "environment": "development"
        }
      }'
    
  2. Skopiuj compute_policy_id z odpowiedzi i ustaw je dla kolejnych żądań:

    export COMPUTE_POLICY_ID="<compute-policy-id>"
    
  3. Pobierz politykę, aby zweryfikować jej nazwę i ograniczenia produktu. Ta odpowiedź nie obejmuje tagów polityki:

    curl --fail-with-body -sS "$WORKSPACE/api/2.0/policies/compute/$COMPUTE_POLICY_ID" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN"
    

Treść żądania to sam obiekt zasad. Usługa przypisuje compute_policy_id. Wybierz unikalną nazwę wyświetlaną w przestrzeni roboczej, od 1 do 127 znaków.

Udzielenie dostępu do polityki

Użyj Permissions API z typem obiektu compute-policy. Twórca polityki ma CAN_MANAGE.

  1. Korzystając z tożsamości z CAN_MANAGE, nadaj istniejącej grupie przestrzeni roboczej uprawnienie do korzystania z zasady. Zamień lakebase-developers na nazwę swojej grupy:

    curl --fail-with-body -sS -X PATCH \
      "$WORKSPACE/api/2.0/permissions/compute-policy/$COMPUTE_POLICY_ID" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{
        "access_control_list": [
          {
            "group_name": "lakebase-developers",
            "permission_level": "CAN_USE"
          }
        ]
      }'
    
  2. Zweryfikuj grant:

    curl --fail-with-body -sS \
      "$WORKSPACE/api/2.0/permissions/compute-policy/$COMPUTE_POLICY_ID" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN"
    

Użyj user_name, aby przyznać dostęp użytkownikowi lub service_principal_name za pomocą identyfikatora aplikacji nazwy głównej usługi. Zezwalaj CAN_MANAGE , aby podmiot mógł korzystać z polityki i zarządzać jej uprawnieniami. W przypadku niestandardowych polityk CAN_MANAGE również umożliwia aktualizację konfiguracji i usunięcie polityki. PATCH aktualizuje określone granty. PUT zastępuje bezpośrednie przypisania uprawnień, więc uwzględnij pełny zestaw, który zamierzasz zachować.

Wymagaj niestandardowej polityki do tworzenia projektów Lakebase

Jako administrator przestrzeni roboczej wykonaj następujące kroki, aby wymagać od użytkowników wyboru polityki niestandardowej:

  1. Wyświetl listę zasad, zgodnie z wartościami next_page_token. Znajdź domyślną politykę Lakebase według jej wartości is_default i wpisu lakebase w allowed_compute_products. Skopiuj jego compute_policy_id.
  2. Udziel użytkownikom lub grupom, których to dotyczy, dostępu do niestandardowej polityki umożliwiającej korzystanie z Lakebase.
  3. W przypadku istniejących projektów Lakebase korzystających z domyślnej polityki zastąp przypisaną politykę, jeśli użytkownicy muszą nadal zmieniać ustawienia zarządzanego zasobu obliczeniowego. Cofnięcie dostępu do polityki domyślnej uniemożliwia wprowadzanie tych zmian w zasobach obliczeniowych, które nadal z niej korzystają.
  4. Pobierz uprawnienia domyślnej polityki za pomocą GET /api/2.0/permissions/compute-policy/<default-policy-id>. Przejrzyj zarówno przydziały użytkowników, jak i dla grup. Domyślna polityka początkowo przyznaje dostęp grupie users , więc samo usunięcie bezpośredniego przyzwolenia użytkownika nie usuwa dostępu tego użytkownika.
  5. Zamień przypisania bezpośrednich uprawnień na PUT /api/2.0/permissions/compute-policy/<default-policy-id>. Uwzględnij bezpośrednie nadania, które zamierzasz zachować, w access_control_list, a pomiń nadania, które dają dostęp użytkownikom, których to dotyczy. Zastąp users szeroki grant grantami dla konkretnych grup, jeśli niektórzy użytkownicy powinni zachować dostęp do domyślnej polityki. Każdy wpis żądania używa nazwy głównej oraz permission_level, jak w przykładzie grantu. Nie wysyłaj odpowiedzi uprawnień GET bez zmian jako treści żądania PUT.
  6. Jako dotknięty użytkownik ponownie wyświetl polityki. Sprawdź, czy niestandardowa zasada jest dostępna, a domyślna zasada już nie. Użytkownik musi teraz podać identyfikator zasad niestandardowych podczas tworzenia projektu Lakebase.

Używaj polityki z projektami Lakebase

Użyj API Postgres (/api/2.0/postgres/), aby tworzyć i zarządzać projektami Lakebase. Projekt Lakebase zawiera gałęzie, a punkty końcowe obliczeń zapewniają obliczenia dla tych gałęzi. Zobacz Compute i punkty końcowe.

Wybierz politykę obliczeń z spec.compute_policy_id, tworząc projekt Lakebase. Dołączona zasada reguluje konfigurację obliczeń i wymusza wymagane tagi na powiązanych zasobach obliczeniowych. Zarządzanie politykami korzysta z oddzielnego /api/2.0/policies/compute API.

Utwórz projekt Lakebase z polityką

Użyj tożsamości z CAN_USE lub CAN_MANAGE w utworzonej powyżej polityce:

  1. Utwórz projekt Lakebase z zakresem automatycznego skalowania 2–8 CU i 15-minutowym limitem bezczynności:

    curl --fail-with-body -sS -X POST \
      "$WORKSPACE/api/2.0/postgres/projects?project_id=policy-example" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN" \
      -H "Content-Type: application/json" \
      -d "$(jq -n --arg policy_id "$COMPUTE_POLICY_ID" '{
        "spec": {
          "display_name": "Policy example",
          "compute_policy_id": $policy_id,
          "default_endpoint_settings": {
            "autoscaling_limit_min_cu": 2,
            "autoscaling_limit_max_cu": 8,
            "suspend_timeout_duration": "900s"
          }
        }
      }')"
    

    Wartości pojemności to Lakebase CU. Maksymalnie 8 CU mieści się w limicie 16 CU w zasadzie. Lakebase wyraża limit bezczynności jako czas trwania w sekundach: "900s" równa się 15-minutowemu limitowi polityki. Te domyślne ustawienia konfigurują początkowy zasób obliczeniowy i zapewniają ustawienia początkowe dla nowych zasobów obliczeniowych w projekcie Lakebase.

    Aby również zastosować politykę użycia bezserwerowego, dodaj "budget_policy_id": "<usage-policy-id>" wewnątrz spec, używając identyfikatora polityki, której możesz użyć. Compute otrzymuje tagi z obu polityk.

  2. Skopiuj operację name z odpowiedzi i ustaw ją dla żądania statusu:

    export OPERATION_NAME="<operation-name>"
    
  3. Pobieraj operację, aż done będzie true:

    curl --fail-with-body -sS "$WORKSPACE/api/2.0/postgres/$OPERATION_NAME" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN"
    

    Jeśli odpowiedź zawiera error, rozwiąż ją przed kontynuacją. Żądania tworzenia, aktualizacji i usuwania korzystają z tego długotrwałego wzorca operacji.

Przeczytaj i wypisz projekty Lakebase

  1. Pobierz informacje o projekcie Lakebase:

    curl --fail-with-body -sS "$WORKSPACE/api/2.0/postgres/projects/policy-example" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN"
    
  2. Sprawdź, czy status.compute_policy_id pasuje do wybranej polityki.

  3. Wymień projekty Lakebase, do których masz dostęp:

    curl --fail-with-body -sS "$WORKSPACE/api/2.0/postgres/projects" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN"
    

Jeśli odpowiedź listy zawiera next_page_token, przekaż tę wartość jako page_token, aby pobrać następną stronę.

Aktualizuj projekt Lakebase

Użyj tożsamości z CAN_MANAGE w projekcie Lakebase. Zmiana nazwy wyświetlanej nie wymaga uprawnień do korzystania z polityki obliczeń.

  1. Zaktualizuj nazwę wyświetlaną projektu Lakebase, określając pole w masce aktualizacji:

    curl --fail-with-body -sS -X PATCH \
      "$WORKSPACE/api/2.0/postgres/projects/policy-example?update_mask=spec.display_name" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{"spec": {"display_name": "Lakebase development"}}'
    
  2. Poczekaj na zakończenie zwróconej operacji, a następnie pobierz projekt Lakebase, aby zweryfikować zmianę.

Zmiana pojemności projektu Lakebase lub domyślnych ustawień obliczeń skalowania do zera wymaga również elementu CAN_MANAGE lub CAN_USE w zasadach, nawet jeśli nie ustawia limitu dla tego ustawienia. Nowe wartości muszą spełniać wszelkie obowiązujące limity zasad. Wartości domyślne obowiązują przy tworzeniu nowych instancji obliczeniowych. Aby zmienić istniejący zestaw obliczeniowy, zaktualizuj jego punkt końcowy, jak pokazano w poniższej procedurze.

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

Aktualizowanie instancji compute Lakebase

Poniższy przykład podnosi maksymalną moc istniejącego obliczenia do 16 CU i skraca czas bezczynności do 10 minut. Potrzebujesz CAN_MANAGE w projekcie Lakebase oraz CAN_USE lub CAN_MANAGE w zasadach dostępu:

  1. Wymień endpointy na gałęzi production projektu Lakebase:

    curl --fail-with-body -sS \
      "$WORKSPACE/api/2.0/postgres/projects/policy-example/branches/production/endpoints" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN"
    
  2. Skopiuj punkt końcowy name początkowego compute z odpowiedzi. Nazwa obejmuje projekt Lakebase, gałąź i ścieżkę końcową:

    export ENDPOINT_NAME="<endpoint-name>"
    
  3. Zaktualizuj maksymalną wartość CU i skalowanie do zera. Użyj spec.suspension w masce aktualizacji dla limitu czasu bezczynności:

    curl --fail-with-body -sS -X PATCH \
      "$WORKSPACE/api/2.0/postgres/$ENDPOINT_NAME?update_mask=spec.autoscaling_limit_max_cu,spec.suspension" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{
        "spec": {
          "autoscaling_limit_max_cu": 16,
          "suspend_timeout_duration": "600s"
        }
      }'
    
  4. Poczekaj na zakończenie zwróconej operacji, a następnie pobierz punkt końcowy:

    curl --fail-with-body -sS "$WORKSPACE/api/2.0/postgres/$ENDPOINT_NAME" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN"
    

    Zweryfikuj status.autoscaling_limit_max_cu i status.suspend_timeout_duration.

Zaktualizowane maksimum mieści się w limicie zasad wynoszącym 16 CU, a "600s" jest poniżej jego 15-minutowego limitu bezczynności. W przypadku tych zasobów obliczeniowych żądania powyżej 16 CU, limity bezczynności powyżej 15 minut lub wyłączenie ustawienia skalowania do zera nie przechodzą walidacji zasad. Wybierz ustawienia mieszczące się w granicach polityki lub poproś menedżera polityki o ich przegląd.

Zamień politykę projektu Lakebase

Potrzebujesz CAN_MANAGE do projektu Lakebase oraz CAN_USE lub CAN_MANAGE w odniesieniu do zarówno bieżącej polityki, jak i jej zastąpienia. Polityka zastępcza musi umożliwiać Lakebase.

Zmiana polityk to aktualizacja konfiguracji. Istniejąca moc obliczeniowa projektu Lakebase i jej domyślne ustawienia muszą spełniać ograniczenia polityki zastępczej, zanim aktualizacja będzie mogła się zakończyć.

  1. Wybierz politykę zastępczą i ustaw jej identyfikator:

    export REPLACEMENT_COMPUTE_POLICY_ID="<replacement-policy-id>"
    
  2. Zweryfikuj, czy projekt Lakebase ma domyślne ustawienia compute oraz istniejącą moc obliczeniową spełniające limity pojemności i czasu bezczynności polityki zastępczej. Zaktualizuj istniejące zasoby obliczeniowe i w razie potrzeby dostosuj ustawienia domyślne.

  3. Zaktualizuj przypisanie polityki projektu Lakebase:

    curl --fail-with-body -sS -X PATCH \
      "$WORKSPACE/api/2.0/postgres/projects/policy-example?update_mask=spec.compute_policy_id" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN" \
      -H "Content-Type: application/json" \
      -d "$(jq -n --arg policy_id "$REPLACEMENT_COMPUTE_POLICY_ID" '{
        "spec": {
          "compute_policy_id": $policy_id
        }
      }')"
    
  4. Poczekaj, aż zwrócona operacja zakończy się za pomocą done: true. Jeśli zawiera error, rozwiąż problem przed kontynuacją.

  5. Pobierz projekt Lakebase i sprawdź, czy status.compute_policy_id odpowiada identyfikatorowi polityki zastępczej:

    curl --fail-with-body -sS "$WORKSPACE/api/2.0/postgres/projects/policy-example" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN"
    

Wyczyszczenie pola spec.compute_policy_id wybiera Domyślną politykę Lakebase i wymaga uprawnień do jej użycia. Nie pozostawia projektu Lakebase bez polityki.

Usuń projekt Lakebase

Domyślnie usunięcie projektu Lakebase czyni go niedostępnym i zachowuje go na potrzeby odzyskania w trakcie okresu retencji. Usunięcie projektu Lakebase nie usuwa polityki przestrzeni roboczej.

  1. Usuń przykładowy projekt Lakebase:

    curl --fail-with-body -sS -X DELETE \
      "$WORKSPACE/api/2.0/postgres/projects/policy-example" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN"
    
  2. Poczekaj na zakończenie zwróconej operacji. Wymagania dotyczące usuwania, w tym chronionych gałęzi, znajdziesz w Usuwanie projektu.

Zarządzanie zasadami

Użyj następujących operacji, aby sprawdzać i utrzymywać polityki w swoim obszarze roboczym.

Pobierz i wyświetlaj polityki

Wyświetl pojedynczą politykę za pomocą GET /api/2.0/policies/compute/{compute_policy_id}, jak pokazano w sekcji Tworzenie polityki. Aby wyświetlić polityki, których możesz używać lub którymi zarządzasz, uruchom:

curl --fail-with-body -sS "$WORKSPACE/api/2.0/policies/compute?page_size=100" \
  -H "Authorization: Bearer $DATABRICKS_TOKEN"

Odpowiedź zawiera compute_policies i, gdy dostępne są kolejne wyniki, next_page_token. Przekaż ten token jako page_token w następnym żądaniu. Domyślny rozmiar strony to 100, a maksymalny to 150. Wyniki nie są sortowane. Każda polityka zawiera can_manage i can_use dla tożsamości wywołującej. is_default Identyfikuje domyślną politykę.

Aktualizowanie zasady

Aktualizacje polityk wymagają parametru zapytania update_mask. Obsługiwane ścieżki to display_name i allowed_compute_products. Aby zaktualizować oba, oddziel ścieżki przecinkiem. Ten punkt końcowy nie obsługuje aktualizacji tags.

  1. Pobierz politykę i przejrzyj ustawienia, które zamierzasz zachować.

  2. Wyślij zmienione pola. Na przykład podnieś limit pojemności przykładowej polityki do 32 CU i zachowaj 15-minutowy limit bezczynności:

    curl --fail-with-body -sS -X PATCH \
      "$WORKSPACE/api/2.0/policies/compute/$COMPUTE_POLICY_ID?update_mask=allowed_compute_products" \
      -H "Authorization: Bearer $DATABRICKS_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{
        "allowed_compute_products": {
          "lakebase": {
            "max_capacity_units_per_instance": 32,
            "max_idle_minutes_before_scale_to_zero": 15
          }
        }
      }'
    
  3. Sprawdź zwróconą politykę, aby zweryfikować zaktualizowany limit.

Aktualizacja obiektu lakebase zastępuje jego ograniczenia. Uwzględnij każde ograniczenie Lakebase, które zamierzasz zachować. Na przykład pominięcie istniejącego limitu czasu bezczynności usuwa ten limit. Pusty obiekt lakebase usuwa swoje ograniczenia, jednocześnie nadal zezwalając na Lakebase. Zagnieżdżone ścieżki masek, takie jak allowed_compute_products.lakebase.max_capacity_units_per_instance, nie są obsługiwane.

Aby zmienić nazwę polityki bez zmiany jej ograniczeń, użyj update_mask=display_name oraz treści, takiej jak {"display_name": "Lakebase application policy"}.

Obniżenie limitu pojemności polityki z 16 do 8 CU pozostawia istniejące zasoby obliczeniowe 16-CU bez zmian. Każda późniejsza zmiana mocy musi być zgodna z limitem 8-CU. Podczas przełączania na inną politykę, istniejące obliczenia muszą spełniać ograniczenia tej polityki, zanim aktualizacja będzie mogła się zakończyć.

Usuwanie zasad

Usunięcie zasady nie usuwa zasobów obliczeniowych utworzonych za pomocą tej zasady. Egzekwowanie jej ograniczeń zależy od tego, czy polityka nadal istnieje i pozostaje przypisana.

Przed usunięciem niestandardowej polityki:

  1. Wyświetl projekty Lakebase, zgodnie z dowolnymi wartościami next_page_token. Znajdź projekty Lakebase, których status.compute_policy_id odpowiada zasadzie, którą planujesz usunąć.
  2. Potwierdź, że spis obejmuje wszystkie projekty Lakebase, których to dotyczy. CAN_MANAGE w zasadach nie przyznaje dostępu do każdego projektu Lakebase, który z nich korzysta. Koordynuj działania z właścicielami projektów Lakebase lub administratorem przestrzeni roboczej dla projektów, których nie możesz przeglądać.
  3. Zamień politykę na dotkniętych projektach Lakebase przed jej usunięciem, jeśli te projekty muszą pozostać regulowane przez politykę.

Aby usunąć niestandardową politykę, uruchom:

curl --fail-with-body -sS -X DELETE \
  "$WORKSPACE/api/2.0/policies/compute/$COMPUTE_POLICY_ID" \
  -H "Authorization: Bearer $DATABRICKS_TOKEN"

Domyślnej polityki Lakebase nie można usunąć.

Troubleshooting

Błąd lub warunek Action
PERMISSION_DENIED podczas tworzenia projektu Lakebase Upewnij się, że masz uprawnienia CAN_USE lub CAN_MANAGE w polityce, która zezwala na Lakebase. Jeśli pominiesz identyfikator polityki, potrzebujesz dostępu do domyślnej polityki Lakebase.
PERMISSION_DENIED podczas aktualizacji konfiguracji zasobów Zweryfikuj swoje uprawnienia do zarządzania zasobem. Zmiany ustawień obliczeń regulowanych przez politykę również wymagają CAN_USE lub CAN_MANAGE dla zasady, nawet jeśli zasada nie ustala limitu dla tego ustawienia. Zobacz Uprawnienia do zmian konfiguracji.
PERMISSION_DENIED podczas zastępowania dołączonej polityki Zweryfikuj swoje uprawnienia do zarządzania zasobem i CAN_USE lub CAN_MANAGE zarówno w odniesieniu do bieżącej polityki, jak i jej zamiennika.
BAD_REQUEST ponieważ wydajność przekracza maksymalny limit zasady Zmniejsz autoscaling_limit_max_cu w konfiguracji punktu końcowego lub domyślne ustawienia zasobów obliczeniowych projektu Lakebase, aby zmieścić się w limicie CU polityki.
BAD_REQUEST ponieważ limit czasu bezczynności przekracza maksymalny limit zasad polityki Włącz skalowanie do zera i wybierz limit bezczynności na poziomie lub poniżej limitu polityki, w zasobie obliczeniowym obsługującym skalowanie do zera.
INVALID_PARAMETER_VALUE podczas tworzenia lub aktualizowania polityki Sprawdź, czy nazwa jest niepusta i ma maksymalnie 127 znaków, co najmniej jeden produkt obliczeniowy jest obecny, limity to dodatnie liczby całkowite, a maska aktualizacji zawiera obsługiwane ścieżki. Domyślne nazwy zasad i konfiguracja nie mogą być zmieniane.
ALREADY_EXISTS podczas nadawania nazwy zasadzie Wybierz inną nazwę. Domyślne nazwy zasad są zarezerwowane.

Ograniczenia

Zarządzanie zasadami

  • Polityki dotyczą obszaru roboczego. Utwórz i przyznaj dostęp do zasad w każdej przestrzeni roboczej, w której ich używasz.
  • Domyślnej polityki Lakebase nie można usunąć ani zmienić jej nazwy czy konfiguracji. Administratorzy przestrzeni roboczej mogą przyznawać lub cofać uprawnienia do tego obiektu.
  • Usunięcie polityki z zasobu wymaga zastąpienia jej inną polityką. Potrzebujesz uprawnień do zarządzania zasobem oraz CAN_USE lub CAN_MANAGE w przypadku obu zasad. Istniejąca moc obliczeniowa musi spełniać wymagania zasad wymiany, zanim aktualizacja będzie mogła się zakończyć.
  • Zaostrzenie polityki nie zmienia istniejącej mocy obliczeniowej. Późniejsze zmiany ustawień zarządzanych muszą spełniać zaktualizowane limity.
  • Usunięcie niestandardowej polityki nie usuwa zasobów obliczeniowych utworzonych przy użyciu tej polityki. Egzekwowanie ograniczeń tej zasady zależy od dalszego istnienia tej zasady.
  • API polityki nie zwraca tagów w odpowiedziach get ani list, ani nie obsługuje zmiany tagów przez punkt końcowy aktualizacji polityki.

Moc obliczeniowa Lakebase

  • Zmiana mocy obliczeniowej lub ustawień skalowania do zera wymaga CAN_MANAGE w projekcie Lakebase oraz CAN_USE lub CAN_MANAGE w jego polityce. Dotyczy to nawet sytuacji, gdy zasada nie ustala limitu dla tego ustawienia.
  • Skalowanie do zera wymaga maksymalnego rozmiaru obliczeniowego 32 CU lub mniejszego. Jeśli polityka wymaga limitu czasu bezczynności, wybierz kompatybilny rozmiar obliczeń. Zobacz Konfiguracja skali do zera.
  • Wysoka dostępność wykorzystuje grupę obliczeniową z wieloma węzłami i wymaga wyłączenia skalowania do zera. Limit czasu bezczynności w polityce nie dotyczy tych grup. Limity przepustowości nadal obowiązują.
  • Zmiana domyślnych ustawień obliczeniowych projektu Lakebase wpływa na nowe zasoby obliczeniowe. Aktualizuj istniejące endpointy obliczeniowe osobno, aby zmienić ich wydajność lub limit bezczynności.

Kompatybilność API instancji bazy danych

API instancji bazy danych pozostaje dostępne dla istniejącej automatyzacji. Używa nazw instancji i poziomów przydzielonej pojemności oraz tworzy projekty Lakebase na platformie Autoscaling. Korzystaj z API Postgres do nowych integracji. Projekty Lakebase tworzone przez API Postgres lub interfejs Lakebase UI nie mogą być zarządzane przez API instancji bazy danych. Zobacz Interfejsy API.

API instancji bazy danych używa domyślnej polityki Lakebase. Utworzenie projektu Lakebase za pomocą tego interfejsu API wymaga uprawnienia CAN_MANAGE lub CAN_USE w ramach tej polityki. Pomiń compute_policy_id lub zostaw go pusty. Wartość niepusta jest odrzucana zarówno przy żądaniach tworzenia, jak i aktualizacji. Aby wybrać niestandardową politykę, użyj API Postgres.

API kompatybilności wykorzystuje następujące pola:

Purpose Pole API instancji bazy danych
Zweryfikuj zastosowaną politykę effective_compute_policy_id w odpowiedzi wystąpienia.
Konfigurowanie pojemności capacity, używając warstwy Provisioned, takiej jak CU_1. Zobacz mapowanie poziomów.
Wybierz politykę korzystania bezserwerowego Poziom najwyższego rzędu usage_policy_id. Tagi z obu zasad mają zastosowanie.

Użytkownicy bez dostępu do domyślnej polityki muszą korzystać z API Postgres z niestandardową polityką, którą mogą wykorzystać do utworzenia projektu Lakebase.

Dodatkowe zasoby