Dokumentacja zasad obliczeniowych

Ten artykuł zawiera informacje dotyczące definicji zasad obliczeniowych. Artykuły zawierają odwołanie do 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.

Obsługiwane atrybuty

Zasady obsługują wszystkie atrybuty kontrolowane za pomocą interfejsu API klastró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 obsługiwane ścieżki atrybutów zasad:

Ścieżki atrybutów wirtualnych

Ta tabela zawiera dwa dodatkowe syntetyczne atrybuty obsługiwane przez zasady:

Specjalne wartości zasad dla wyboru środowiska Databricks Runtime

Atrybut spark_version obsługuje specjalne wartości, które dynamicznie mapuje się na wersję środowiska Databricks Runtime na podstawie bieżącego zestawu obsługiwanych wersji środowiska 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: Mapuje na najnowszą wersję uczenia maszynowego środowiska Databricks Runtime.
• auto:latest-lts: mapuje najnowszą długoterminową wersję środowiska Databricks Runtime .
• auto:latest-lts-ml: mapuje na najnowszą wersję uczenia maszynowego środowiska Databricks Runtime LTS.
• auto:prev-major: mapuje na drugą najnowszą wersję ogólnie dostępnego środowiska Databricks Runtime. Na przykład jeśli auto:latest ma wartość 14.2, wartość auto:prev-major to 13.3.
• auto:prev-major-ml: mapuje na drugą najnowszą wersję uczenia maszynowego usługi Databricks Runtime. Na przykład jeśli auto:latest ma wartość 14.2, wartość auto:prev-major to 13.3.
• auto:prev-lts: mapuje na drugą najnowszą wersję środowiska Uruchomieniowego LTS Databricks. Na przykład jeśli auto:latest-lts ma wartość 13.3, wartość auto:prev-lts to 12.2.
• auto:prev-lts-ml: mapuje na drugą najnowszą wersję ŚRODOWISKA ML środowiska Databricks Runtime LTS. Na przykład jeśli auto:latest-lts ma wartość 13.3, wartość 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.

Naprawiono zasady uniemożliwiające konfigurację użytkownika w atrybucie. Dwa typy stałych zasad to:

• Naprawiono zasady
• Zasady zabronione

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 ograniczania.

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

• Zasady listy dozwolonych
• Zasady listy bloków
• Zasady wyrażeń regularnych
• Zasady zakresu
• Nieograniczone zasady

Naprawiono zasady

Naprawiono zasady ograniczające atrybut do określonej wartości. W przypadku wartości atrybutów innych niż liczbowe i logiczne wartość musi być reprezentowana przez lub konwertowane na ciąg.

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

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

Te przykładowe zasady naprawiają wersję środowiska Databricks Runtime i ukrywają pole w interfejsie użytkownika:

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

Zasady zabronione

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 zasady.

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

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

Zasady listy bloków

Zasady listy zablokowanych wyświetla 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 użytkownik nie może wybrać 7.3.x-scala2.12 środowiska Databricks Runtime.

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

Zasady 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 zakotwiczone na początku i na 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].*" }
}

Zasady zakresu

Zasady zakresu ograniczają wartość do określonego zakresu przy użyciu minValue pól 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ąć wartość minValue lub maxValue.

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

Ten przykład ogranicza maksymalną ilość procesów roboczych do 10:

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

Nieograniczone zasady

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 tag jest dodany 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 zasad 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 tworzenia zasobów obliczeniowych.
• isOptional - Zasady ograniczające atrybut automatycznie sprawia, że jest to wymagane. Aby ustawić atrybut jako opcjonalny, ustaw isOptional pole na truewartość .

Ta przykładowa zasada określa wartość id1 domyślną puli dla węzłów procesu roboczego, ale sprawia, że jest ona opcjonalna. Podczas tworzenia zasobów obliczeniowych możesz wybrać inną pulę lub nie użyć tej puli. Jeśli driver_instance_pool_id nie zdefiniowano w zasadach lub podczas tworzenia obliczeń, ta sama pula jest używana dla węzłów procesu roboczego i węzła sterownika.

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

Pisanie zasad dotyczących atrybutów tablicy

Zasady dla 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. To ograniczenie używa liczby w ścieżce.

Na przykład dla atrybutu init_scriptstablicy ścieżki ogólne zaczynają się od init_scripts.* i określone ścieżki z 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 dołączania

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

Nie zezwalaj na całkowite użycie

{
   "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 init_scripts ścieżek tablica może zawierać jedną z wielu struktur, dla których może być konieczne obsłużenie wszystkich możliwych wariantów w zależności od 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ć rodzin zasad udostępnianych przez usługę Azure Databricks jako szablonów typowych przypadków użycia zasad.

• Ogólne zasady obliczeniowe
• Definiowanie limitów obliczeniowych potoku tabel na żywo usługi Delta
• Proste zasady średniej wielkości
• Zasady dotyczące tylko zadań
• Zasady zewnętrznego magazynu metadanych
• Zapobieganie użyciu zasobów obliczeniowych z zadaniami
• Usuwanie zasad skalowania automatycznego
• Wymuszanie 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 obliczeniowych potoku tabel na żywo usługi Delta

Aby skonfigurować zasady dla obliczeń potoku, utwórz zasady z polem ustawionym cluster_type na dlt. Poniższy przykład tworzy minimalne zasady dla obliczeń tabel delta live:

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

Proste zasady ś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"
  }
}

Zasady dotyczące tylko zadań

Umożliwia użytkownikom tworzenie zasobów obliczeniowych zadań do uruchamiania 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 magazynu 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>"
  }
}

Zapobieganie użyciu zasobów obliczeniowych z zadaniami

Te zasady uniemożliwiają użytkownikom używanie obliczeń do uruchamiania zadań. Użytkownicy będą mogli korzystać tylko z obliczeń z notesami.

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

Usuwanie zasad skalowania automatycznego

Te zasady wyłącza skalowanie automatyczne i umożliwia użytkownikowi ustawienie liczby procesów roboczych w danym zakresie.

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

Wymuszanie 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 tych zasad musi wypełnić COST_CENTER tag 9999, 9921 lub 9531, aby środowisko obliczeniowe było uruchamiane:

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