Spuštění poznámkového bloku Databricks z jiného poznámkového bloku

Důležité

Pro orchestraci poznámkových bloků použijte úlohy Databricks. Pro scénáře modularizace kódu použijte soubory pracovního prostoru. Techniky popsané v tomto článku byste měli použít jenom v případě, že váš případ použití nelze implementovat pomocí úlohy Databricks, například pro vytváření smyček poznámkových bloků přes dynamickou sadu parametrů nebo pokud nemáte přístup k souborům pracovního prostoru. Další informace najdete v tématu Úlohy Databricks a sdílení kódu.

%run Porovnání adbutils.notebook.run()

Příkaz %run umožňuje zahrnout do poznámkového bloku další poznámkový blok. Ke modularizaci kódu můžete použít %run například vložením podpůrných funkcí do samostatného poznámkového bloku. Můžete ho také použít ke zřetězení poznámkových bloků, které implementují kroky v analýze. Když použijete %run, zavolá se poznámkový blok okamžitě spustí a funkce a proměnné definované v něm budou v volajícím poznámkovém bloku k dispozici.

Toto dbutils.notebook rozhraní API je doplněk %run , protože umožňuje předávat parametry a vracet hodnoty z poznámkového bloku. Díky tomu můžete vytvářet složité pracovní postupy a kanály se závislostmi. Můžete například získat seznam souborů v adresáři a předat názvy do jiného poznámkového bloku, což není možné s %run. Můžete také vytvořit pracovní postupy if-then-else na základě vrácených hodnot nebo volat jiné poznámkové bloky pomocí relativních cest.

Na rozdíl od %runmetody dbutils.notebook.run() spustí novou úlohu pro spuštění poznámkového bloku.

Tyto metody, jako jsou všechna dbutils rozhraní API, jsou k dispozici pouze v Pythonu a Scala. Můžete ale použít dbutils.notebook.run() k vyvolání poznámkového bloku jazyka R.

Použití %run k importu poznámkového bloku

V tomto příkladu první poznámkový blok definuje funkci, reversekterá je k dispozici v druhém poznámkovém bloku po použití %run magie ke spuštění shared-code-notebook.

Vzhledem k tomu, že oba tyto poznámkové bloky jsou ve stejném adresáři v pracovním prostoru, použijte předponu ././shared-code-notebook k označení, že cesta by měla být přeložena vzhledem k aktuálně běžícímu poznámkovému bloku. Poznámkové bloky můžete uspořádat do adresářů, jako je například , nebo použít absolutní cestu, například %run ./dir/notebook%run /Users/username@organization.com/directory/notebook.

Poznámka:

• %run musí být v buňce samostatně, protože běží celý vložený poznámkový blok.
• Nelze použít %run ke spuštění souboru Pythonu a import entit definovaných v daném souboru do poznámkového bloku. Pokud chcete importovat ze souboru Pythonu, přečtěte si téma Modularizace kódu pomocí souborů. Nebo soubor zabalte do knihovny Pythonu, vytvořte z této knihovny Pythonu knihovnu Azure Databricks a nainstalujte ji do clusteru, který používáte ke spuštění poznámkového bloku.
• Pokud používáte %run ke spuštění poznámkového bloku obsahujícího widgety, spustí se ve výchozím nastavení zadaný poznámkový blok s výchozími hodnotami widgetu. Můžete také předat hodnoty widgetům; Viz Použití widgetů Databricks s %run.

dbutils.notebook Rozhraní api

Metody dostupné v dbutils.notebook rozhraní API jsou run a exit. Parametry i návratové hodnoty musí být řetězce.

run(path: String, timeout_seconds: int, arguments: Map): String

Spusťte poznámkový blok a vraťte jeho výstupní hodnotu. Metoda spustí dočasný úkol, který se spustí okamžitě.

Parametr timeout_seconds řídí časový limit spuštění (0 znamená žádný časový limit): Volání run vyvolá výjimku, pokud se nedokončí v zadaném čase. Pokud je Služba Azure Databricks mimo provoz déle než 10 minut, spuštění poznámkového bloku selže bez ohledu na to timeout_seconds.

Parametr arguments nastaví hodnoty widgetu cílového poznámkového bloku. Konkrétně pokud má spuštěný poznámkový blok widget s názvem Aa předáte dvojici ("A": "B") klíč-hodnota jako součást parametru run() argumentů volání, pak načtení hodnoty widgetu A vrátí "B". Pokyny pro vytváření a práci s widgety najdete v článku o widgetech Databricks .

Poznámka:

• Parametr arguments přijímá pouze znaky latinky (znaková sada ASCII). Použití znaků jiného typu než ASCII vrátí chybu.
• Úlohy vytvořené pomocí dbutils.notebook rozhraní API se musí dokončit za 30 dnů nebo méně.

run Použití

Python

dbutils.notebook.run("notebook-name", 60, {"argument": "data", "argument2": "data2", ...})

Scala

dbutils.notebook.run("notebook-name", 60, Map("argument" -> "data", "argument2" -> "data2", ...))

run Příklad

Předpokládejme, že máte poznámkový blok s názvem workflowsfoo widgetu, který vytiskne hodnotu widgetu:

dbutils.widgets.text("foo", "fooDefault", "fooEmptyLabel")
print(dbutils.widgets.get("foo"))

Spuštění dbutils.notebook.run("workflows", 60, {"foo": "bar"}) vytvoří následující výsledek:

Widget měl hodnotu, kterou jste předali pomocí dbutils.notebook.run(), "bar"místo výchozího.

exit(value: String): void Ukončete poznámkový blok s hodnotou. Pokud zavoláte poznámkový blok pomocí run metody, vrátí se tato hodnota.

dbutils.notebook.exit("returnValue")

Volání dbutils.notebook.exit do úlohy způsobí úspěšné dokončení poznámkového bloku. Pokud chcete způsobit selhání úlohy, vyvoláte výjimku.

Příklad

V následujícím příkladu předáte argumenty a DataImportNotebook spustíte různé poznámkové bloky (DataCleaningNotebook nebo ErrorHandlingNotebook) na základě výsledku z DataImportNotebook.

Po spuštění kódu se zobrazí tabulka obsahující odkaz na spuštěný poznámkový blok:

Pokud chcete zobrazit podrobnosti o spuštění, klikněte v tabulce na odkaz Čas zahájení. Pokud je spuštění dokončené, můžete také zobrazit podrobnosti o spuštění kliknutím na odkaz Čas ukončení .

Předávání strukturovaných dat

Tato část ukazuje, jak předávat strukturovaná data mezi poznámkovými bloky.

Python

# Example 1 - returning data through temporary views.
# You can only return one string using dbutils.notebook.exit(), but since called notebooks reside in the same JVM, you can
# return a name referencing data stored in a temporary view.

## In callee notebook
spark.range(5).toDF("value").createOrReplaceGlobalTempView("my_data")
dbutils.notebook.exit("my_data")

## In caller notebook
returned_table = dbutils.notebook.run("LOCATION_OF_CALLEE_NOTEBOOK", 60)
global_temp_db = spark.conf.get("spark.sql.globalTempDatabase")
display(table(global_temp_db + "." + returned_table))

# Example 2 - returning data through DBFS.
# For larger datasets, you can write the results to DBFS and then return the DBFS path of the stored data.

## In callee notebook
dbutils.fs.rm("/tmp/results/my_data", recurse=True)
spark.range(5).toDF("value").write.format("parquet").save("dbfs:/tmp/results/my_data")
dbutils.notebook.exit("dbfs:/tmp/results/my_data")

## In caller notebook
returned_table = dbutils.notebook.run("LOCATION_OF_CALLEE_NOTEBOOK", 60)
display(spark.read.format("parquet").load(returned_table))

# Example 3 - returning JSON data.
# To return multiple values, you can use standard JSON libraries to serialize and deserialize results.

## In callee notebook
import json
dbutils.notebook.exit(json.dumps({
  "status": "OK",
  "table": "my_data"
}))

## In caller notebook
import json

result = dbutils.notebook.run("LOCATION_OF_CALLEE_NOTEBOOK", 60)
print(json.loads(result))

Scala

// Example 1 - returning data through temporary views.
// You can only return one string using dbutils.notebook.exit(), but since called notebooks reside in the same JVM, you can
// return a name referencing data stored in a temporary view.

/** In callee notebook */
sc.parallelize(1 to 5).toDF().createOrReplaceGlobalTempView("my_data")
dbutils.notebook.exit("my_data")

/** In caller notebook */
val returned_table = dbutils.notebook.run("LOCATION_OF_CALLEE_NOTEBOOK", 60)
val global_temp_db = spark.conf.get("spark.sql.globalTempDatabase")
display(table(global_temp_db + "." + returned_table))

// Example 2 - returning data through DBFS.
// For larger datasets, you can write the results to DBFS and then return the DBFS path of the stored data.

/** In callee notebook */
dbutils.fs.rm("/tmp/results/my_data", recurse=true)
sc.parallelize(1 to 5).toDF().write.format("parquet").save("dbfs:/tmp/results/my_data")
dbutils.notebook.exit("dbfs:/tmp/results/my_data")

/** In caller notebook */
val returned_table = dbutils.notebook.run("LOCATION_OF_CALLEE_NOTEBOOK", 60)
display(sqlContext.read.format("parquet").load(returned_table))

// Example 3 - returning JSON data.
// To return multiple values, you can use standard JSON libraries to serialize and deserialize results.

/** In callee notebook */

// Import jackson json libraries
import com.fasterxml.jackson.module.scala.DefaultScalaModule
import com.fasterxml.jackson.module.scala.experimental.ScalaObjectMapper
import com.fasterxml.jackson.databind.ObjectMapper

// Create a json serializer
val jsonMapper = new ObjectMapper with ScalaObjectMapper
jsonMapper.registerModule(DefaultScalaModule)

// Exit with json
dbutils.notebook.exit(jsonMapper.writeValueAsString(Map("status" -> "OK", "table" -> "my_data")))

/** In caller notebook */

// Import jackson json libraries
import com.fasterxml.jackson.module.scala.DefaultScalaModule
import com.fasterxml.jackson.module.scala.experimental.ScalaObjectMapper
import com.fasterxml.jackson.databind.ObjectMapper

// Create a json serializer
val jsonMapper = new ObjectMapper with ScalaObjectMapper
jsonMapper.registerModule(DefaultScalaModule)

val result = dbutils.notebook.run("LOCATION_OF_CALLEE_NOTEBOOK", 60)
println(jsonMapper.readValue[Map[String, String]](result))

Zpracování chyb

Tato část ukazuje, jak řešit chyby.

Python

# Errors throw a WorkflowException.

def run_with_retry(notebook, timeout, args = {}, max_retries = 3):
  num_retries = 0
  while True:
    try:
      return dbutils.notebook.run(notebook, timeout, args)
    except Exception as e:
      if num_retries > max_retries:
        raise e
      else:
        print("Retrying error", e)
        num_retries += 1

run_with_retry("LOCATION_OF_CALLEE_NOTEBOOK", 60, max_retries = 5)

Scala

// Errors throw a WorkflowException.

import com.databricks.WorkflowException

// Since dbutils.notebook.run() is just a function call, you can retry failures using standard Scala try-catch
// control flow. Here we show an example of retrying a notebook a number of times.
def runRetry(notebook: String, timeout: Int, args: Map[String, String] = Map.empty, maxTries: Int = 3): String = {
  var numTries = 0
  while (true) {
    try {
      return dbutils.notebook.run(notebook, timeout, args)
    } catch {
      case e: WorkflowException if numTries < maxTries =>
        println("Error, retrying: " + e)
    }
    numTries += 1
  }
  "" // not reached
}

runRetry("LOCATION_OF_CALLEE_NOTEBOOK", timeout = 60, maxTries = 5)

Spuštění více poznámkových bloků současně

Více poznámkových bloků můžete spustit současně pomocí standardních konstruktorů Scala a Pythonu, jako jsou Vlákna (Scala, Python) a Futures (Scala, Python). Ukázkové poznámkové bloky ukazují, jak tyto konstrukce používat.

1. Stáhněte si následující 4 poznámkové bloky. Poznámkové bloky jsou napsané v jazyce Scala.
2. Naimportujte poznámkové bloky do jedné složky v pracovním prostoru.
3. Spusťte souběžně poznámkový blok Spustit.

Souběžné spuštění poznámkového bloku

Získat poznámkový blok

Spuštění paralelního poznámkového bloku

Získat poznámkový blok

Testovací poznámkový blok

Získat poznámkový blok

Poznámkový blok Testing-2

Získat poznámkový blok