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

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:

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

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

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 zdefiniowana w zasadach lub podczas tworzenia klastra obliczeniowego, ta sama pula jest używana dla węzłów roboczych i węzła sterującego.

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

Pisanie zasad dla 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. 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 potoku DLT
• Prosta średniej wielkości polisa
• polityka dotycząca wyłącznie pracy
• zewnętrzne zasady 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"
  }
}

Określanie limitów obliczeń przepływu DLT

Aby skonfigurować politykę dla potoku obliczeń, utwórz ją z polem cluster_type ustawionym na dlt. Poniższy przykład tworzy minimalne zasady dla obliczeń DLT:

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