Dokumentacja zasad obliczeniowych

Ta strona jest odwołaniem do definicji zasad obliczeniowych, w tym listy dostępnych atrybutów zasad i typów ograniczeń. Istnieją również przykładowe zasady, do których można się odwoływać w przypadku typowych przypadków użycia.

Co to są definicje zasad?

Definicje zasad to poszczególne reguły zasad wyrażone w formacie JSON.

Definicja może dodać regułę do dowolnego atrybutu kontrolowanego za pomocą interfejsu API klastrów . Na przykład te definicje ustawiają domyślny czas autoterminacji, zabraniają użytkownikom korzystania z pul i wymuszają użycie aplikacji Photon:

{
  "autotermination_minutes": {
    "type": "unlimited",
    "defaultValue": 4320,
    "isOptional": true
  },
  "instance_pool_id": {
    "type": "forbidden",
    "hidden": true
  },
  "runtime_engine": {
    "type": "fixed",
    "value": "PHOTON",
    "hidden": true
  }
}

Może istnieć tylko jedno ograniczenie na atrybut. Ścieżka atrybutu odzwierciedla nazwę atrybutu interfejsu-API. W przypadku atrybutów zagnieżdżonych ścieżka łączy zagnieżdżone nazwy atrybutów przy użyciu kropek. Atrybuty, które nie są zdefiniowane w definicji zasad, nie będą ograniczone.

Konfigurowanie definicji zasad przy użyciu nowego formularza zasad

Nowy formularz zasad umożliwia konfigurowanie definicji zasad przy użyciu menu rozwijanych i innych elementów interfejsu użytkownika. Oznacza to, że administratorzy mogą pisać zasady bez konieczności nauki lub odwołowania się do składni zasad.

Definicje zasad JSON są nadal obsługiwane w nowym formularzu. Można je dodać do pola Niestandardowy kod JSON w obszarze Opcje zaawansowane.

Znane ograniczenia korzystające z nowego formularza zasad

Jeśli zasady nie są obsługiwane przez nowy formularz zasad obliczeniowych, wszystkie niezgodne definicje będą wyświetlane w polu niestandardowym JSON w sekcji Opcje zaawansowane . W poniższych polach obsługiwane są tylko podzestaw prawidłowych zasad:

• workload_type: Zasady muszą definiować wartości i workload_type.clients.notebooksworkload_type.clients.jobs. Każda z tych reguł musi być stała na true wartość lub false.
• dbus_per_hour: obsługiwane są tylko zasady zakresu, które określają maxValue i nie określają minValue .
• ssh_public_keys: obsługiwane są tylko stałe zasady. Zasady ssh_public_keys nie mogą pomijać żadnych indeksów. Na przykład , ssh_public_keys.0ssh_public_keys.1, ssh_public_keys.2 jest prawidłowy, ale ssh_public_keys.0, ssh_public_keys.2, ssh_public_keys.3 jest nieprawidłowy.
• cluster_log_conf: cluster_log_conf.path nie może być listą dozwolonych ani listą zablokowanych.
• init_scripts: zasady indeksowane (tj init_scripts.0.volumes.destination. ) muszą zostać naprawione. Zasady z symbolami wieloznacznymi (tj init_scripts.*.volumes.destination. ) muszą być zabronione. Indeksowane zasady nie mogą pomijać żadnych indeksów.

Atrybuty obsługiwane

Zasady obejmują wszystkie atrybuty kontrolowane za pomocą API Klasterów. Typ ograniczeń, które można umieścić na atrybutach, może się różnić w zależności od ich typu i relacji z elementami interfejsu użytkownika. Nie można używać zasad do definiowania uprawnień obliczeniowych.

Możesz również użyć zasad, aby ustawić maksymalną liczbę jednostek DBU na godzinę i typ klastra. Zobacz Ścieżki atrybutów wirtualnych.

W poniższej tabeli wymieniono dostępne ścieżki atrybutów zasad:

ścieżki atrybutów wirtualnych

Ta tabela zawiera dwa dodatkowe syntetyczne atrybuty obsługiwane przez zasady. Jeśli używasz nowego formularza zasad, te atrybuty można ustawić w sekcji Opcje zaawansowane .

Elastyczne typy węzłów

Atrybuty elastycznych typów węzłów umożliwiają określenie alternatywnych typów węzłów, których może używać zasób obliczeniowy, jeśli typ węzła podstawowego jest niedostępny. Te atrybuty mają specjalne wymagania dotyczące zasad:

• Obsługiwane są tylko stałe zasady. Wszystkie inne typy zasad są niedozwolone i zostaną odrzucone w czasie tworzenia zasad.
• Pusty ciąg w polityce odpowiada pustej liście alternatywnych typów węzłów, co skutecznie wyłącza elastyczne typy węzłów.

Poprawka do określonej listy typów węzłów

W przeciwieństwie do odpowiednich pól interfejsu API klastrów, które używają tablicy ciągów, atrybuty zasad obliczeniowych używają pojedynczej wartości ciągu, która koduje tablicę typów węzłów jako listę rozdzielaną przecinkami. Na przykład:

{
  "worker_node_type_flexibility.alternate_node_type_ids": {
    "type": "fixed",
    "value": "nodeA,nodeB"
  }
}

Jeśli używasz interfejsu API klastrów do tworzenia zasobu obliczeniowego z przypisanymi zasadami, Databricks zaleca, aby nie ustawiać pól worker_node_type_flexibility lub driver_node_type_flexibility. Jeśli ustawisz te pola, typy węzłów i kolejność tablicy muszą być zgodne z listą rozdzielaną przecinkami zasad dokładnie lub nie można utworzyć obliczeń. Na przykład definicja zasad z powyższego zostanie ustawiona jako:

"worker_node_type_flexibility": {
  "alternate_node_type_ids": ["nodeA", "nodeB"]
}

Wyłączanie elastycznych typów węzłów

Aby wyłączyć elastyczne typy węzłów, ustaw wartość na pusty ciąg. Na przykład:

{
  "worker_node_type_flexibility.alternate_node_type_ids": {
    "type": "fixed",
    "value": ""
  }
}

Specjalne wartości zasad dla wyboru środowiska Databricks Runtime

Atrybut spark_version obsługuje specjalne wartości, które dynamicznie mapują się do wersji środowiska Databricks Runtime na podstawie bieżącego zestawu obsługiwanych wersji Databricks Runtime.

W atrybucie spark_version można użyć następujących wartości:

• auto:latest: mapuje na najnowszą wersję ogólnie dostępnego środowiska Databricks Runtime.
• auto:latest-ml: Odpowiada najnowszej wersji środowiska Databricks Runtime ML.
• auto:latest-lts: odnosi się do najnowszej wersji środowiska Databricks Runtime z obsługą długoterminową (LTS).
• auto:latest-lts-ml: odnosi się do najnowszej wersji Databricks Runtime ML z długoterminowym wsparciem (LTS).
• auto:prev-major: mapuje na przedostatnią wersję ogólnie dostępnego środowiska Databricks Runtime. Jeśli na przykład auto:latest ma wartość 14.2, auto:prev-major wynosi 13,3.
• auto:prev-major-ml: Odnosi się do przedostatniej wersji GA Databricks Runtime ML. Jeśli na przykład auto:latest ma wartość 14.2, auto:prev-major wynosi 13,3.
• auto:prev-lts: Odpowiada przedostatniej wersji LTS środowiska wykonawczego Databricks. Jeśli na przykład auto:latest-lts ma wartość 13.3, auto:prev-lts to 12.2.
• auto:prev-lts-ml: odnosi się do drugiej najnowszej wersji LTS Databricks Runtime ML. Jeśli na przykład auto:latest-lts ma wartość 13.3, auto:prev-lts to 12.2.

Obsługiwane typy zasad

Ta sekcja zawiera informacje dotyczące każdego z dostępnych typów zasad. Istnieją dwie kategorie typów zasad: stałe zasady i zasady ograniczające.

Sztywne zasady uniemożliwiają konfigurację atrybutu przez użytkownika. Dwa typy stałych zasad to:

• Stała zasada
• Zabroniona zasada

Ograniczanie zasad ogranicza opcje użytkownika do konfigurowania atrybutu. Ograniczenie zasad pozwala również ustawić wartości domyślne i ustawić atrybuty opcjonalne. Zobacz Dodatkowe pola zasad ograniczające.

Dostępne są następujące opcje ograniczania zasad:

• Polityka listy dozwolonych
• Polityka listy blokowanych
• zasady wyrażeń regularnych
• Polityka zakresu
• nieograniczona polisa

stała polityka

Ustalono zasady ograniczające atrybut do określonej wartości. W przypadku wartości atrybutów innych niż liczbowe i logiczne, wartość musi być przedstawiona jako ciąg lub możliwa do przekształcenia w ciąg.

W przypadku stałych zasad można również ukryć atrybut z interfejsu użytkownika, ustawiając pole hidden na wartość true.

interface FixedPolicy {
    type: "fixed";
    value: string | number | boolean;
    hidden?: boolean;
}

Przykładowa polityka ustala wersję środowiska Databricks Runtime i ukrywa pole w interfejsie użytkownika.

{
  "spark_version": { "type": "fixed", "value": "auto:latest-lts", "hidden": true }
}

Zabroniona polityka

Zasady zabronione uniemożliwiają użytkownikom konfigurowanie atrybutu. Zasady zabronione są zgodne tylko z atrybutami opcjonalnymi.

interface ForbiddenPolicy {
    type: "forbidden";
}

Te zasady zabraniają dołączania pul do obliczeń dla węzłów roboczych. Pule są również zabronione dla węzła sterownika, ponieważ driver_instance_pool_id dziedziczy politykę.

{
  "instance_pool_id": { "type": "forbidden" }
}

polityka listy dozwolonych

Zasady listy dozwolonych określają listę wartości, które użytkownik może wybrać podczas konfigurowania atrybutu.

interface AllowlistPolicy {
  type: "allowlist";
  values: (string | number | boolean)[];
  defaultValue?: string | number | boolean;
  isOptional?: boolean;
}

Ten przykład listy dozwolonych umożliwia użytkownikowi wybór między dwiema wersjami środowiska Databricks Runtime:

{
  "spark_version": { "type": "allowlist", "values": ["13.3.x-scala2.12", "12.2.x-scala2.12"] }
}

polityka listy zablokowanych

Zasady polityki bloklisty zawierają niedozwolone wartości. Ponieważ wartości muszą być dokładnie zgodne, te zasady mogą nie działać zgodnie z oczekiwaniami, gdy atrybut jest łagodny w sposobie reprezentowania wartości (na przykład zezwalanie na spacje wiodące i końcowe).

interface BlocklistPolicy {
  type: "blocklist";
  values: (string | number | boolean)[];
  defaultValue?: string | number | boolean;
  isOptional?: boolean;
}

W tym przykładzie uniemożliwia się użytkownikowi wybór 7.3.x-scala2.12 jako środowiska Databricks Runtime.

{
  "spark_version": { "type": "blocklist", "values": ["7.3.x-scala2.12"] }
}

Polityka wyrażeń regularnych

Zasady wyrażeń regularnych ograniczają dostępne wartości do tych, które pasują do wyrażenia regularnego. Aby zapewnić bezpieczeństwo, upewnij się, że wyrażenie regularne jest osadzone na początku i końcu wartości ciągu.

interface RegexPolicy {
  type: "regex";
  pattern: string;
  defaultValue?: string | number | boolean;
  isOptional?: boolean;
}

Ten przykład ogranicza wersje środowiska Databricks Runtime, z których użytkownik może wybrać:

{
  "spark_version": { "type": "regex", "pattern": "13\\.[3456].*" }
}

Polityka zakresu

Zasady zakresu ograniczają wartość do określonego zakresu przy użyciu pól minValue i maxValue. Wartość musi być liczbą dziesiętną. Limity liczbowe muszą być reprezentowane jako podwójna wartość zmiennoprzecinkowa. Aby wskazać brak określonego limitu, można pominąć minValue lub maxValue.

interface RangePolicy {
  type: "range";
  minValue?: number;
  maxValue?: number;
  defaultValue?: string | number | boolean;
  isOptional?: boolean;
}

Ten przykład ogranicza maksymalną liczbę pracowników do 10.

{
  "num_workers": { "type": "range", "maxValue": 10 }
}

nieograniczona polityka

Nieograniczone zasady służą do ustawiania atrybutów wymaganych lub ustawiania wartości domyślnej w interfejsie użytkownika.

interface UnlimitedPolicy {
  type: "unlimited";
  defaultValue?: string | number | boolean;
  isOptional?: boolean;
}

W tym przykładzie dodano tag COST_BUCKET do obliczeń:

{
  "custom_tags.COST_BUCKET": { "type": "unlimited" }
}

Aby ustawić wartość domyślną zmiennej konfiguracji platformy Spark, ale także zezwolić na pominięcie (usunięcie) zmiennej:

{
  "spark_conf.spark.my.conf": { "type": "unlimited", "isOptional": true, "defaultValue": "my_value" }
}

dodatkowe pola polityki ograniczające

W przypadku ograniczania typów zasad można określić dwa dodatkowe pola:

• defaultValue — wartość, która automatycznie wypełnia się w interfejsie użytkownika używanym do tworzenia obliczeń.
• isOptional — zasady ograniczające atrybut automatycznie sprawia, że jest to wymagane. Aby ustawić atrybut jako opcjonalny, ustaw pole isOptional na wartość true.

Przykładowa zasada ustala wartość domyślną id1 dla puli węzłów roboczych, ale jej użycie jest opcjonalne. Podczas tworzenia zasobów obliczeniowych możesz wybrać inną pulę lub nie użyć tej puli. Jeśli driver_instance_pool_id nie jest zdefiniowany w zasadach lub podczas tworzenia obliczeń, ta sama pula jest używana dla roboczych węzłów i węzła kierującego.

{
  "instance_pool_id": { "type": "unlimited", "isOptional": true, "defaultValue": "id1" }
}

Pisanie zasad dla atrybutów tablicy

Zasady dotyczące atrybutów tablicy można określić na dwa sposoby:

• Ograniczenia ogólne dotyczące wszystkich elementów tablicy. Te ograniczenia używają symbolu wieloznacznego * w ścieżce zasad.
• Określone ograniczenia dotyczące elementu tablicy w określonym indeksie. Te ograniczenia używają liczby w ścieżce.

Na przykład dla atrybutu tablicy init_scriptsścieżki ogólne zaczynają się od init_scripts.* i określone ścieżki zaczynają się od init_scripts.<n>, gdzie <n> jest indeksem całkowitym w tablicy (począwszy od 0). Można połączyć ogólne i specyficzne ograniczenia, w tym przypadku ogólne ograniczenie dotyczy każdego elementu tablicy, który nie ma określonego ograniczenia. W każdym przypadku zostanie zastosowane tylko jedno ograniczenie zasad.

W poniższych sekcjach przedstawiono przykłady typowych przykładów, które używają atrybutów tablicy.

Wymaganie wpisów specyficznych dla inkluzji

Nie można wymagać określonych wartości bez określania kolejności. Na przykład:

{
  "init_scripts.0.volumes.destination": {
    "type": "fixed",
    "value": "<required-script-1>"
  },
  "init_scripts.1.volumes.destination": {
    "type": "fixed",
    "value": "<required-script-2>"
  }
}

Wymagaj stałej wartości całej listy

{
  "init_scripts.0.volumes.destination": {
    "type": "fixed",
    "value": "<required-script-1>"
  },
  "init_scripts.*.volumes.destination": {
    "type": "forbidden"
  }
}

Całkowicie zabroń użycia

{
  "init_scripts.*.volumes.destination": {
    "type": "forbidden"
  }
}

Zezwalaj na wpisy, które są zgodne z określonym ograniczeniem

{
  "init_scripts.*.volumes.destination": {
    "type": "regex",
    "pattern": ".*<required-content>.*"
  }
}

Naprawianie określonego zestawu skryptów inicjowania

W przypadku ścieżek init_scripts tablica może zawierać jedną z wielu struktur, a wszystkie możliwe warianty muszą być obsłużone w zależności od konkretnego przypadku użycia. Aby na przykład wymagać określonego zestawu skryptów inicjowania i nie zezwalać na dowolny wariant innej wersji, można użyć następującego wzorca:

{
  "init_scripts.0.volumes.destination": {
    "type": "fixed",
    "value": "<volume-paths>"
  },
  "init_scripts.1.volumes.destination": {
    "type": "fixed",
    "value": "<volume-paths>"
  },
  "init_scripts.*.workspace.destination": {
    "type": "forbidden"
  },
  "init_scripts.*.abfss.destination": {
    "type": "forbidden"
  },
  "init_scripts.*.file.destination": {
    "type": "forbidden"
  }
}

Przykłady zasad

Ta sekcja zawiera przykłady zasad, których można użyć jako odwołań do tworzenia własnych zasad. Można również użyć dostępnych rodzin zasad usługi Azure Databricks jako szablonów typowych przypadków użycia zasad.

• ogólne zasady obliczeniowe
• Ustalanie limitów obliczeń w deklaratywnych potokach Spark na platformie Lakeflow
• Prosta średniej wielkości polisa
• polityka dotycząca wyłącznie pracy
• Polityka zewnętrznego magazynu metadanych
• Zapobiegaj użyciu zasobów obliczeniowych w połączeniu z zadaniami
• Usuwanie zasad skalowania automatycznego
• egzekwowanie tagów niestandardowych

Ogólne zasady obliczeniowe

Zasady obliczeniowe ogólnego przeznaczenia przeznaczone do kierowania użytkownikami i ograniczania niektórych funkcji, jednocześnie wymagając tagów, ograniczając maksymalną liczbę wystąpień i wymuszając limit czasu.

{
  "instance_pool_id": {
    "type": "forbidden",
    "hidden": true
  },
  "spark_version": {
    "type": "regex",
    "pattern": "12\\.[0-9]+\\.x-scala.*"
  },
  "node_type_id": {
    "type": "allowlist",
    "values": ["Standard_L4s", "Standard_L8s", "Standard_L16s"],
    "defaultValue": "Standard_L16s_v2"
  },
  "driver_node_type_id": {
    "type": "fixed",
    "value": "Standard_L16s_v2",
    "hidden": true
  },
  "autoscale.min_workers": {
    "type": "fixed",
    "value": 1,
    "hidden": true
  },
  "autoscale.max_workers": {
    "type": "range",
    "maxValue": 25,
    "defaultValue": 5
  },
  "autotermination_minutes": {
    "type": "fixed",
    "value": 30,
    "hidden": true
  },
  "custom_tags.team": {
    "type": "fixed",
    "value": "product"
  }
}

Definiowanie limitów w obliczeniach deklaratywnych potoków platformy Spark w usłudze Lakeflow

Aby skonfigurować politykę dla potoku obliczeń, utwórz ją z polem cluster_type ustawionym na dlt. Poniższy przykład obejmuje tworzenie minimalnych zasad obliczeniowych potoków deklaratywnych platformy Spark w usłudze Lakeflow:

{
  "cluster_type": {
    "type": "fixed",
    "value": "dlt"
  },
  "num_workers": {
    "type": "unlimited",
    "defaultValue": 3,
    "isOptional": true
  },
  "node_type_id": {
    "type": "unlimited",
    "isOptional": true
  },
  "spark_version": {
    "type": "unlimited",
    "hidden": true
  }
}

Prosta polisa średniej wielkości

Umożliwia użytkownikom tworzenie średniej wielkości zasobów obliczeniowych z minimalną konfiguracją. Jedynym wymaganym polem w czasie tworzenia jest nazwa obliczeniowa; reszta jest stała i ukryta.

{
  "instance_pool_id": {
    "type": "forbidden",
    "hidden": true
  },
  "spark_conf.spark.databricks.cluster.profile": {
    "type": "forbidden",
    "hidden": true
  },
  "autoscale.min_workers": {
    "type": "fixed",
    "value": 1,
    "hidden": true
  },
  "autoscale.max_workers": {
    "type": "fixed",
    "value": 10,
    "hidden": true
  },
  "autotermination_minutes": {
    "type": "fixed",
    "value": 60,
    "hidden": true
  },
  "node_type_id": {
    "type": "fixed",
    "value": "Standard_L8s_v2",
    "hidden": true
  },
  "driver_node_type_id": {
    "type": "fixed",
    "value": "Standard_L8s_v2",
    "hidden": true
  },
  "spark_version": {
    "type": "fixed",
    "value": "auto:latest-ml",
    "hidden": true
  },
  "custom_tags.team": {
    "type": "fixed",
    "value": "product"
  }
}

Polityka wyłącznie dotycząca pracy

Umożliwia użytkownikom tworzenie zasobów obliczeniowych do wykonywania zadań. Użytkownicy nie mogą tworzyć obliczeń ogólnego przeznaczenia przy użyciu tych zasad.

{
  "cluster_type": {
    "type": "fixed",
    "value": "job"
  },
  "dbus_per_hour": {
    "type": "range",
    "maxValue": 100
  },
  "instance_pool_id": {
    "type": "forbidden",
    "hidden": true
  },
  "num_workers": {
    "type": "range",
    "minValue": 1
  },
  "node_type_id": {
    "type": "regex",
    "pattern": "Standard_[DLS]*[1-6]{1,2}_v[2,3]"
  },
  "driver_node_type_id": {
    "type": "regex",
    "pattern": "Standard_[DLS]*[1-6]{1,2}_v[2,3]"
  },
  "spark_version": {
    "type": "unlimited",
    "defaultValue": "auto:latest-lts"
  },
  "custom_tags.team": {
    "type": "fixed",
    "value": "product"
  }
}

Zasady zewnętrznego repozytorium metadanych

Umożliwia użytkownikom tworzenie obliczeń za pomocą już dołączonego magazynu metadanych zdefiniowanych przez administratora. Jest to przydatne, aby umożliwić użytkownikom tworzenie własnych zasobów obliczeniowych bez konieczności dodatkowej konfiguracji.

{
  "spark_conf.spark.hadoop.javax.jdo.option.ConnectionURL": {
    "type": "fixed",
    "value": "jdbc:sqlserver://<jdbc-url>"
  },
  "spark_conf.spark.hadoop.javax.jdo.option.ConnectionDriverName": {
    "type": "fixed",
    "value": "com.microsoft.sqlserver.jdbc.SQLServerDriver"
  },
  "spark_conf.spark.databricks.delta.preview.enabled": {
    "type": "fixed",
    "value": "true"
  },
  "spark_conf.spark.hadoop.javax.jdo.option.ConnectionUserName": {
    "type": "fixed",
    "value": "<metastore-user>"
  },
  "spark_conf.spark.hadoop.javax.jdo.option.ConnectionPassword": {
    "type": "fixed",
    "value": "<metastore-password>"
  }
}

Zablokuj użycie zasobów obliczeniowych w zadaniach

Te zasady uniemożliwiają użytkownikom używanie obliczeń do uruchamiania zadań. Użytkownicy będą mogli korzystać tylko z zasobów obliczeniowych za pomocą notebooków.

{
  "workload_type.clients.notebooks": {
    "type": "fixed",
    "value": true
  },
  "workload_type.clients.jobs": {
    "type": "fixed",
    "value": false
  }
}

Usuwanie zasad skalowania automatycznego

Ta zasada wyłącza skalowanie automatyczne i umożliwia użytkownikowi ustawienie liczby pracowników w danym zakresie.

{
  "num_workers": {
    "type": "range",
    "maxValue": 25,
    "minValue": 1,
    "defaultValue": 5
  }
}

Egzekwowanie tagów niestandardowych

Aby dodać regułę tagu obliczeniowego do zasad, użyj atrybutu custom_tags.<tag-name>.

Na przykład każdy użytkownik korzystający z tej polityki musi wypełnić tag COST_CENTER wartością 9999, 9921 lub 9531, aby uruchomić środowisko obliczeniowe.

{ "custom_tags.COST_CENTER": { "type": "allowlist", "values": ["9999", "9921", "9531"] } }