Databricks-jegyzetfüzet futtatása egy másik jegyzetfüzetből
Fontos
Jegyzetfüzet-vezényléshez használja a Databricks Jobsot. A kód modularizálási forgatókönyveihez használjon munkaterület-fájlokat. Csak akkor használja a cikkben leírt technikákat, ha a használati eset nem implementálható Databricks-feladattal, például a jegyzetfüzetek dinamikus paraméterekkel való hurkolásához, vagy ha nem fér hozzá a munkaterület fájljaihoz. További információ: Munkafolyamatok ütemezése és vezénylása, valamint kód megosztása.
Összehasonlítás és %run
dbutils.notebook.run()
A %run
parancs lehetővé teszi, hogy egy másik jegyzetfüzetet is belefoglaljon egy jegyzetfüzetbe. A kód modularizálására használható %run
, például a támogató függvények külön jegyzetfüzetbe való elhelyezésével. Az elemzés lépéseit megvalósító jegyzetfüzetek összefűzésére is használható. A használat %run
során a rendszer azonnal végrehajtja a hívott jegyzetfüzetet, és a benne definiált függvények és változók elérhetővé válnak a hívó jegyzetfüzetben.
Az dbutils.notebook
API azért kiegészítő, %run
mert lehetővé teszi paraméterek átadását és visszaadni egy jegyzetfüzet értékeit. Így összetett munkafolyamatokat és folyamatokat hozhat létre függőségekkel. Lekérheti például a címtárban lévő fájlok listáját, és átadhatja a neveket egy másik jegyzetfüzetnek, ami nem lehetséges %run
. Ha másként is létrehozhat munkafolyamatokat a visszatérési értékek alapján, vagy meghívhat más jegyzetfüzeteket relatív elérési utak használatával.
Ellentétben %run
a dbutils.notebook.run()
metódus egy új feladatot indít el a jegyzetfüzet futtatásához.
Ezek a metódusok, mint az dbutils
összes API, csak a Pythonban és a Scalában érhetők el. Az R-jegyzetfüzeteket azonban meghívhatja dbutils.notebook.run()
.
Jegyzetfüzet %run
importálása
Ebben a példában az első jegyzetfüzet egy függvényt határoz meg, reverse
amely a második jegyzetfüzetben érhető el, miután a varázslatot használta a %run
végrehajtáshoz shared-code-notebook
.
Mivel mindkét jegyzetfüzet ugyanabban a könyvtárban található a munkaterületen, az előtaggal ./
./shared-code-notebook
jelezheti, hogy az elérési utat a jelenleg futó jegyzetfüzethez képest kell feloldani. A jegyzetfüzeteket rendezheti könyvtárakba, például %run ./dir/notebook
, vagy használhat abszolút elérési utat, például %run /Users/username@organization.com/directory/notebook
.
Feljegyzés
%run
önmagában kell lennie egy cellának, mert a teljes jegyzetfüzetet beágyazottan futtatja.- Nem használható
%run
Python-fájl ésimport
a fájlban definiált entitások jegyzetfüzetbe való futtatására. Ha Python-fájlból szeretne importálni, olvassa el a kód modularizálása fájlok használatával című témakört. Vagy csomagolja be a fájlt egy Python-kódtárba, hozzon létre egy Azure Databricks-tárat abból a Python-kódtárból, és telepítse a tárat abba a fürtbe, amelyet a jegyzetfüzet futtatásához használ. - Ha widgeteket tartalmazó jegyzetfüzetet futtat
%run
, a megadott jegyzetfüzet alapértelmezés szerint a widget alapértelmezett értékeivel fut. Az értékeket a widgeteknek is átadhatja; lásd: Databricks-vezérlők használata a következővel: %run.
dbutils.notebook
API
Az API-ban dbutils.notebook
elérhető metódusok a következők run
: és exit
. A paramétereknek és a visszatérési értékeknek sztringeknek kell lenniük.
run(path: String, timeout_seconds: int, arguments: Map): String
Futtasson egy jegyzetfüzetet, és adja vissza a kilépési értékét. A metódus elindít egy rövid élettartamú feladatot, amely azonnal lefut.
A timeout_seconds
paraméter szabályozza a futtatás időtúllépését (a 0 azt jelenti, hogy run
nincs időtúllépés): a hívás kivételt jelez, ha az nem fejeződik be a megadott időn belül. Ha az Azure Databricks több mint 10 percig leállt, a jegyzetfüzet futtatása a rendszertől függetlenül timeout_seconds
meghiúsul.
A arguments
paraméter beállítja a céljegyzetfüzet widgetértékét. Pontosabban, ha a futtatott jegyzetfüzetben van egy widget neve A
, és az argumentumparaméter részeként egy kulcs-érték párot ("A": "B")
ad át a run()
hívásnak, akkor a widget A
értékének lekérése vissza fog térni "B"
. A widgetek létrehozásához és használatához szükséges utasításokat a Databricks widgetekről szóló cikkben találja.
Feljegyzés
- A
arguments
paraméter csak latin karaktereket fogad el (ASCII-karakterkészlet). A nem ASCII-karakterek használata hibát ad vissza. - Az
dbutils.notebook
API-val létrehozott feladatoknak legalább 30 nap alatt be kell fejeződniük.
run
Használat
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élda
Tegyük fel, hogy van egy jegyzetfüzete workflows
, amelynek neve egy widget, foo
amely a widget értékét nyomtatja:
dbutils.widgets.text("foo", "fooDefault", "fooEmptyLabel")
print(dbutils.widgets.get("foo"))
A futtatás dbutils.notebook.run("workflows", 60, {"foo": "bar"})
a következő eredményt hozza létre:
A widget az alapértelmezett helyett a használt dbutils.notebook.run()
"bar"
értéket adta meg.
exit(value: String): void
Lépjen ki egy értékekkel rendelkező jegyzetfüzetből. Ha a run
metódussal hív meg egy jegyzetfüzetet, akkor ez a visszaadott érték.
dbutils.notebook.exit("returnValue")
A feladat behívása dbutils.notebook.exit
miatt a jegyzetfüzet sikeresen befejeződött. Ha azt szeretné, hogy a feladat meghiúsuljon, kivételt kell adnia.
Példa
Az alábbi példában argumentumokat DataImportNotebook
ad át különböző jegyzetfüzeteknek (DataCleaningNotebook
vagy ErrorHandlingNotebook
) az eredmény DataImportNotebook
alapján.
A kód futtatásakor megjelenik egy tábla, amely a futó jegyzetfüzetre mutató hivatkozást tartalmazza:
A futtatás részleteinek megtekintéséhez kattintson a táblában a Kezdési idő hivatkozásra. Ha a futtatás befejeződött, a futtatás részleteit a Befejezési idő hivatkozásra kattintva is megtekintheti.
Strukturált adatok átadása
Ez a szakasz bemutatja, hogyan továbbíthat strukturált adatokat a jegyzetfüzetek között.
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))
Hibakezelés
Ez a szakasz a hibák kezelését mutatja be.
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)
Több jegyzetfüzet egyidejű futtatása
Egyszerre több jegyzetfüzetet is futtathat szabványos Scala- és Python-szerkezetekkel, például Szálak (Scala, Python) és Futures (Scala, Python) használatával. A példajegyzetfüzetek bemutatják, hogyan használhatók ezek a szerkezetek.
- Töltse le a következő 4 jegyzetfüzetet. A jegyzetfüzetek a Scalában vannak megírva.
- Importálja a jegyzetfüzeteket a munkaterület egyetlen mappájába.
- Futtassa az egyidejűleg futtatott jegyzetfüzetet.