NotebookUtils (bývalý MSSparkUtils) pre Fabric

Notebook Utilities (NotebookUtils) je vstavaný balík, ktorý vám pomôže jednoducho vykonávať bežné úlohy v notebooku fabric. NotebookUtils môžete používať na prácu so súborovými systémami, získavanie premenných prostredia, reťazové poznámkové bloky a prácu s tajomstvámi. Balík NotebookUtils je k dispozícii v nástrojoch Scala (Python) v PySparku, poznámkových blokoch SparkR a kanáloch služby Fabric.

Pomôcky systému súborov

notebookutils.fs poskytuje pomôcky na prácu s rôznymi súborovými systémami vrátane služby Azure Data Lake Storage (ADLS) Gen2 a služby Azure Blob Storage. Nezabudnite nakonfigurovať prístup k službe Azure Data Lake Storage Gen2 a úložisku Azure Blob Storage správne.

Spustite nasledujúce príkazy a získajte prehľad dostupných metód:

notebookutils.fs.help()

Výkon

notebookutils.fs provides utilities for working with various FileSystems.

Below is overview about the available methods:

cp(from: String, to: String, recurse: Boolean = false): Boolean -> Copies a file or directory, possibly across FileSystems
fastcp(from: String, to: String, recurse: Boolean = true): Boolean -> [Preview] Copies a file or directory via azcopy, possibly across FileSystems
mv(from: String, to: String, createPath: Boolean = false, overwrite: Boolean = false): Boolean -> Moves a file or directory, possibly across FileSystems
ls(dir: String): Array -> Lists the contents of a directory
mkdirs(dir: String): Boolean -> Creates the given directory if it does not exist, also creating any necessary parent directories
put(file: String, contents: String, overwrite: Boolean = false): Boolean -> Writes the given String out to a file, encoded in UTF-8
head(file: String, maxBytes: int = 1024 * 100): String -> Returns up to the first 'maxBytes' bytes of the given file as a String encoded in UTF-8
append(file: String, content: String, createFileIfNotExists: Boolean): Boolean -> Append the content to a file
rm(dir: String, recurse: Boolean = false): Boolean -> Removes a file or directory
exists(file: String): Boolean -> Check if a file or directory exists
mount(source: String, mountPoint: String, extraConfigs: Map[String, Any]): Boolean -> Mounts the given remote storage directory at the given mount point
unmount(mountPoint: String): Boolean -> Deletes a mount point
mounts(): Array[MountPointInfo] -> Show information about what is mounted
getMountPath(mountPoint: String, scope: String = ""): String -> Gets the local path of the mount point

Use notebookutils.fs.help("methodName") for more info about a method.

Pomôcky pre notebookUtils fungujú so systémom súborov rovnakým spôsobom ako rozhrania Spark API. Take notebookutils.fs.mkdirs() a Fabric lakehouse použitie napríklad:

Použitie	Relatívna cesta z koreňa HDFS	Absolútna cesta k systému súborov ABFS	Absolútna cesta k lokálnemu systému súborov v uzli ovládača
Nepláciová priehrada lakehouse	Nepodporované	notebookutils.fs.mkdirs("abfss://< container_name>@<storage_account_name.dfs.core.windows.net/>< new_dir>")	notebookutils.fs.mkdirs("file:/<new_dir>")
Predvolený lakehouse	Adresár v časti "Súbory" alebo "Tabuľky": notebookutils.fs.mkdirs("Files/<new_dir>")	notebookutils.fs.mkdirs("abfss://< container_name>@<storage_account_name.dfs.core.windows.net/>< new_dir>")	notebookutils.fs.mkdirs("file:/<new_dir>")

Súbory zoznamu

Ak chcete zobraziť zoznam obsahu adresára, použite notebookutils.fs.ls ('Cesta k adresáru').. Napríklad:

notebookutils.fs.ls("Files/tmp") # The relatvie path may work with different base path, details in below 
notebookutils.fs.ls("abfss://<container_name>@<storage_account_name>.dfs.core.windows.net/<path>")  # The absolute path, like: ABFS file system
notebookutils.fs.ls("file:/tmp")  # The full path of the local file system of driver node

Rozhranie API notebookutils.fs.ls() sa pri použití relatívnej cesty správa inak v závislosti od typu poznámkového bloku.

• v notebooku Spark: Relatívna cesta je relatívna k predvolenej ceste ABFSS lakehouse. Napríklad notebookutils.fs.ls("Files") odkazuje na Files adresár v predvolenom komplexe Lakehouse.

  Napríklad:

  notebookutils.fs.ls("Files/sample_datasets/public_holidays.parquet")
  

• V poznámkovom bloku jazyka Python: Relatívna cesta je relatívna vzhľadom na pracovný adresár lokálneho systému súborov, ktorý je v predvolenom nastavení /home/trusted-service-user/work. Preto by ste mali namiesto relatívnej cesty použiť úplnú cestu notebookutils.fs.ls("/lakehouse/default/Files") na prístup k adresáru Files v predvolenom komplexe Lakehouse.

  Napríklad:

  notebookutils.fs.ls("/lakehouse/default/Files/sample_datasets/public_holidays.parquet")
  

Zobrazenie vlastností súboru

Táto metóda vráti vlastnosti súboru vrátane názvu súboru, cesty k súboru, veľkosti súboru a toho, či ide o adresár a súbor.

files = notebookutils.fs.ls('Your directory path')
for file in files:
    print(file.name, file.isDir, file.isFile, file.path, file.size)

Vytvorenie nového adresára

Táto metóda vytvorí daný adresár, ak neexistuje, a vytvorí všetky potrebné nadradené adresáre.

notebookutils.fs.mkdirs('new directory name')  
notebookutils.fs.mkdirs("Files/<new_dir>")  # works with the default lakehouse files using relative path 
notebookutils.fs.ls("abfss://<container_name>@<storage_account_name>.dfs.core.windows.net/<new_dir>")  # based on ABFS file system 
notebookutils.fs.ls("file:/<new_dir>")  # based on local file system of driver node 

Kopírovať súbor

Táto metóda skopíruje súbor alebo adresár a podporuje aktivitu kopírovania v súborových systémoch.

notebookutils.fs.cp('source file or directory', 'destination file or directory', True)# Set the third parameter as True to copy all files and directories recursively

Performant copy file

Táto metóda ponúka efektívnejší prístup k kopírovaniu alebo presúvaniu súborov, najmä pri práci s veľkými objemami údajov. Na zvýšenie výkonu v službe fastcp Fabric sa odporúča použiť ako náhrada za tradičnú cp metódu.

notebookutils.fs.fastcp('source file or directory', 'destination file or directory', True)# Set the third parameter as True to copy all files and directories recursively

Zobraziť ukážku obsahu súboru

Táto metóda vráti až prvé bajty "maxBytes" daného súboru ako reťazec kódovaný v UTF-8.

notebookutils.fs.head('file path', maxBytes to read)

Presunutie súboru

Táto metóda premiestni súbor alebo adresár a podporuje presuny do súborových systémov.

notebookutils.fs.mv('source file or directory', 'destination directory', True) # Set the last parameter as True to firstly create the parent directory if it does not exist
notebookutils.fs.mv('source file or directory', 'destination directory', True, True) # Set the third parameter to True to firstly create the parent directory if it does not exist. Set the last parameter to True to overwrite the updates.

Zapisovať súbor

Táto metóda zapíše daný reťazec do súboru, ktorý je kódovaný v UTF-8.

notebookutils.fs.put("file path", "content to write", True) # Set the last parameter as True to overwrite the file if it existed already

Pripojenie obsahu k súboru

Táto metóda pripojí daný reťazec k súboru, ktorý je kódovaný v UTF-8.

notebookutils.fs.append("file path", "content to append", True) # Set the last parameter as True to create the file if it does not exist

Odstránenie súboru alebo adresára

Táto metóda odstráni súbor alebo adresár.

notebookutils.fs.rm('file path', True) # Set the last parameter as True to remove all files and directories recursively

Pripojenie alebo zrušenie pripojenia adresára

Ďalšie informácie o podrobnom používaní nájdete v téme Pripojenie a zrušenie pripojenia súboru.

Pomôcky pre poznámkové bloky

Pomocou pomôcok poznámkového bloku môžete spustiť poznámkový blok alebo ukončiť poznámkový blok s hodnotou. Spustením nasledujúceho príkazu získate prehľad dostupných metód:

notebookutils.notebook.help()

Výstup:

The notebook module.

exit(value: String): void -> This method lets you exit a notebook with a value.
run(path: String, timeoutSeconds: int, arguments: Map, workspace: String): String -> This method runs a notebook and returns its exit value.
runMultiple(DAG: Any): Map[String, MsNotebookRunResult] -> [Preview] Runs multiple notebooks concurrently with support for dependency relationships.
validateDAG(DAG: Any): Boolean -> [Preview] This method check if the DAG is correctly defined.

[Preview] Below methods are only support Fabric Notebook.
create(name: String, description: String = "", content: String = "", defaultLakehouse: String = "", defaultLakehouseWorkspace: String = "", workspaceId: String = ""): Artifact -> Create a new Notebook.
get(name: String, workspaceId: String = ""): Artifact -> Get a Notebook by name or id.
update(name: String, newName: String, description: String = "", workspaceId: String = ""): Artifact -> Update a Artifact by name.
delete(name: String, workspaceId: String = ""): Boolean -> Delete a Notebook by name.
list(workspaceId: String = "", maxResults: Int = 1000): Array[Artifact] -> List all Notebooks in the workspace.
updateDefinition(name: String, content: String = "", defaultLakehouse: String = "", defaultLakehouseWorkspace: String = "", workspaceId: String = "") -> Update the definition of a Notebook.

Use notebookutils.notebook.help("methodName") for more info about a method.

Odkaz na poznámkový blok

Táto metóda odkazuje na poznámkový blok a vráti jeho výstupnú hodnotu. Volania vnorených funkcií môžete spustiť interaktívne v poznámkovom bloke alebo v kanáli. Poznámkový blok, na ktorý sa odkazuje, je spustený vo fonde spark poznámkového bloku, ktorý túto funkciu volá.

notebookutils.notebook.run("notebook name", <timeoutSeconds>, <parameterMap>, <workspaceId>)

Napríklad:

notebookutils.notebook.run("Sample1", 90, {"input": 20 })

Poznámkový blok služby Fabric tiež podporuje odkazovanie na poznámkové bloky vo viacerých pracovných priestoroch zadaním ID pracovného priestoru.

notebookutils.notebook.run("Sample1", 90, {"input": 20 }, "fe0a6e2a-a909-4aa3-a698-0a651de790aa")

Prepojenie na snímku odkazu môžete otvoriť v bunke výstupe. Snímka zaznamenáva výsledky spustenia kódu a umožňuje jednoducho ladiť referenčné spustenie.

Odkaz na paralelné spustenie viacerých poznámkových blokov

Metóda notebookutils.notebook.runMultiple() vám umožňuje spustiť viaceré poznámkové bloky paralelne alebo s preddefinovanou topologickou štruktúrou. Rozhranie API používa mechanizmus implementácie viacerých vlákien v rámci relácie spark, čo znamená, že referenčný poznámkový blok je spustený a zdieľa výpočtové zdroje.

S možnosťou notebookutils.notebook.runMultiple()môžete:

• Vykonajte viacero poznámkových blokov súčasne bez čakania na dokončenie každého z nich.

• Zadajte závislosti a poradie vykonávania pre poznámkové bloky pomocou jednoduchého formátu JSON.

• Optimalizujte použitie výpočtových zdrojov služby Spark a znížte náklady na projekty služby Fabric.

• Zobrazte snímky každého záznamu spúšťania poznámkového bloku vo výstupe a pohodlné ladenie/monitorovanie úloh poznámkového bloku.

• Získajte hodnotu výstupu každej aktivity vedúceho pracovníka a použite ich v následných úlohách.

Môžete tiež skúsiť spustiť notebookutils.notebook.help("runMultiple") a nájsť príklad a podrobné použitie.

Tu je jednoduchý príklad paralelného spustenia zoznamu poznámkových blokov pomocou tejto metódy:

notebookutils.notebook.runMultiple(["NotebookSimple", "NotebookSimple2"])

Výsledok spustenia koreňového poznámkového bloku je nasledovný:

Tu je príklad spustenia poznámkových blokov s topologickou štruktúrou pomocou notebookutils.notebook.runMultiple(). Pomocou tejto metódy môžete jednoducho koordinovať poznámkové bloky prostredníctvom prostredia kódu.

# run multiple notebooks with parameters
DAG = {
    "activities": [
        {
            "name": "NotebookSimple", # activity name, must be unique
            "path": "NotebookSimple", # notebook path
            "timeoutPerCellInSeconds": 90, # max timeout for each cell, default to 90 seconds
            "args": {"p1": "changed value", "p2": 100}, # notebook parameters
        },
        {
            "name": "NotebookSimple2",
            "path": "NotebookSimple2",
            "timeoutPerCellInSeconds": 120,
            "args": {"p1": "changed value 2", "p2": 200}
        },
        {
            "name": "NotebookSimple2.2",
            "path": "NotebookSimple2",
            "timeoutPerCellInSeconds": 120,
            "args": {"p1": "changed value 3", "p2": 300},
            "retry": 1,
            "retryIntervalInSeconds": 10,
            "dependencies": ["NotebookSimple"] # list of activity names that this activity depends on
        }
    ],
    "timeoutInSeconds": 43200, # max timeout for the entire DAG, default to 12 hours
    "concurrency": 50 # max number of notebooks to run concurrently, default to 50
}
notebookutils.notebook.runMultiple(DAG, {"displayDAGViaGraphviz": False})

Výsledok spustenia koreňového poznámkového bloku je nasledovný:

Poskytujeme aj metódu na kontrolu správneho definovania jazyka DAG.

notebookutils.notebook.validateDAG(DAG)

Ukončenie poznámkového bloku

Táto metóda ukončí poznámkový blok s hodnotou. Volania vnorených funkcií môžete spustiť interaktívne v poznámkovom bloke alebo v kanáli.

• Pri interaktívnom volaní funkcie exit() z notebooku poznámkový blok služby Fabric vyvolá výnimku, vynechá spúšťanie nasledujúcich buniek a udržiava reláciu Spark nažive.

• Pri koordinovaní poznámkového bloku v kanáli, ktorý volá funkciu exit(), sa aktivita poznámkového bloka vráti s hodnotou výstupu. Tým sa dokončí spustenie kanála a zastaví sa relácia Spark.

• Keď v notebooku , na ktorý sa odkazuje, vyvolá funkcia exit(), služba Fabric Spark zastaví ďalšie vykonávanie odkazovaného poznámkového bloku a bude naďalej spúšťať ďalšie bunky v hlavnom notebooku, ktorý volá funkciu run( ). Príklad: Notebook1 má tri bunky a v druhej bunke vyvolá funkciu exit( ). Notebook2 má päť buniek a v tretej bunke zavolá run(notebook1 ). Keď spustíte Notebook2, Notebook1 sa pri stlačení funkcie exit() zastaví na druhej bunke. Notebook2 naďalej spúšťa svoju štvrtú bunku a piatu bunku.

notebookutils.notebook.exit("value string")

Napríklad:

Poznámkový blok Ukážka1 s nasledujúcimi dvomi bunkami:

• Bunka 1 definuje vstupný parameter s predvolenou hodnotou nastavenou na hodnotu 10.

• Bunka 2 ukončí poznámkový blok so vstupom ako výstupnou hodnotou.

Vzorku Sample1 môžete spustiť v inom poznámkovom bloku s predvolenými hodnotami:

exitVal = notebookutils.notebook.run("Sample1")
print (exitVal)

Výstup:

Notebook is executed successfully with exit value 10

Vzorku1 môžete spustiť v inom poznámkovom bloku a nastaviť vstupnú hodnotu ako 20:

exitVal = notebookutils.notebook.run("Sample1", 90, {"input": 20 })
print (exitVal)

Výstup:

Notebook is executed successfully with exit value 20

Spravovanie poznámkových blokov artefaktov

notebookutils.notebook Poskytuje špecializované pomôcky na programovú správu položiek poznámkového bloku. Tieto rozhrania API vám môžu pomôcť jednoducho vytvárať, získavať, aktualizovať a odstraňovať položky poznámkového bloku.

Ak chcete efektívne využiť tieto metódy, zvážte nasledujúce príklady používania:

Vytvorenie poznámkového bloku

with open("/path/to/notebook.ipynb", "r") as f:
    content = f.read()

artifact = notebookutils.notebook.create("artifact_name", "description", "content", "default_lakehouse_name", "default_lakehouse_workspace_id", "optional_workspace_id")

Získanie obsahu poznámkového bloku

artifact = notebookutils.notebook.get("artifact_name", "optional_workspace_id")

Aktualizácia poznámkového bloku

updated_artifact = notebookutils.notebook.update("old_name", "new_name", "optional_description", "optional_workspace_id")

updated_artifact_definition = notebookutils.notebook.updateDefinition("artifact_name",  "content", "default_lakehouse_name", "default_Lakehouse_Workspace_name", "optional_workspace_id")

Odstránenie poznámkového bloku

is_deleted = notebookutils.notebook.delete("artifact_name", "optional_workspace_id")

Zápisníky v pracovnom priestore

artifacts_list = notebookutils.notebook.list("optional_workspace_id")

Pomôcky pre prihlasovacie údaje

Pomocou pomôcok poverení môžete získať prístupové tokeny a spravovať tajné kódy v službe Azure Key Vault.

Spustením nasledujúceho príkazu získate prehľad dostupných metód:

notebookutils.credentials.help()

Výstup:

Help on module notebookutils.credentials in notebookutils:

NAME
    notebookutils.credentials - Utility for credentials operations in Fabric

FUNCTIONS
    getSecret(akvName, secret) -> str
        Gets a secret from the given Azure Key Vault.
        :param akvName: The name of the Azure Key Vault.
        :param secret: The name of the secret.
        :return: The secret value.
    
    getToken(audience) -> str
        Gets a token for the given audience.
        :param audience: The audience for the token.
        :return: The token.
    
    help(method_name=None)
        Provides help for the notebookutils.credentials module or the specified method.
        
        Examples:
        notebookutils.credentials.help()
        notebookutils.credentials.help("getToken")
        :param method_name: The name of the method to get help with.

DATA
    creds = <notebookutils.notebookutils.handlers.CredsHandler.CredsHandler...

FILE
    /home/trusted-service-user/cluster-env/trident_env/lib/python3.10/site-packages/notebookutils/credentials.py

Získať token

Funkcia getToken vráti token Microsoft Entra pre danú cieľovú skupinu a meno (voliteľné). Nasledujúci zoznam zobrazuje aktuálne dostupné kľúče cieľovej skupiny:

• Storage Audience Resource: "storage"
• Zdroj služby Power BI: pbi
• Azure Key Vault Resource: "keyvault"
• Synapse RTA KQL DB Zdroj: "kusto"

Spustite nasledujúci príkaz, aby ste získali token:

notebookutils.credentials.getToken('audience Key')

Získanie tajného kódu pomocou poverení používateľa

Funkcia getSecret vráti tajný kód služby Azure Key Vault pre daný koncový bod a meno tajného kódu služby Azure Key Vault pomocou prihlasovacích údajov používateľa.

notebookutils.credentials.getSecret('https://<name>.vault.azure.net/', 'secret name')

Pripojenie a zrušenie pripojenia k súboru

Služba Fabric podporuje nasledujúce možnosti pripojenia v balíku služby Microsoft Spark Utilities. Na pripojenie vzdialeného úložiska (ADLS Gen2) k všetkým pracovným uzlom (uzly vodiča a uzly pracovníkov) môžete použiť rozhrania API pripojiť, zrušiť ich odnímanie, getMountPath() a pripojiť() rozhrania API. Po uložení bodu pripojenia ukladacieho priestoru použite rozhranie API lokálneho súboru na prístup k údajom, akoby boli uložené v lokálnom systéme súborov.

Ako pripojiť konto služby ADLS Gen2

V nasledujúcom príklade je znázornené, ako pripojiť Azure Data Lake Storage Gen2. Montážny úložný priestor objektu BLOB funguje podobne.

Tento príklad predpokladá, že máte jedno konto služby Data Lake Storage Gen2 s názvom storegen2 a konto má jeden kontajner s názvom mycontainer , ktorý chcete pripojiť k relácii Spark v notebooku /testovať .

Ak chcete pripojiť kontajner s názvom mycontainer, notebookutils musí najskôr skontrolovať, či máte povolenie na prístup ku kontajneru. V súčasnosti služba Fabric podporuje dve metódy overovania pre operáciu pripojenia spúšťača: accountKey a sastoken.

Pripojenie prostredníctvom tokenu podpisu zdieľaného prístupu alebo kľúča konta

Pomôcka NotebookUtils podporuje explicitné odovzdanie kľúča konta alebo tokenu Podpis zdieľaného prístupu (SAS) ako parametra na pripojenie cieľa.

Z bezpečnostných dôvodov odporúčame uložiť kľúče kont alebo tokeny SAS v službe Azure Key Vault (ako je znázornené na nasledujúcej snímke obrazovky). Potom ich môžete načítať pomocou notebookutils.credentials.getSecret API. Ďalšie informácie o službe Azure Key Vault nájdete v téme Informácie o kľúčoch konta spravovaného úložiska Azure Key Vault.

Vzorový kód pre metódu accountKey :

# get access token for keyvault resource
# you can also use full audience here like https://vault.azure.net
accountKey = notebookutils.credentials.getSecret("<vaultURI>", "<secretName>")
notebookutils.fs.mount(  
    "abfss://mycontainer@<accountname>.dfs.core.windows.net",  
    "/test",  
    {"accountKey":accountKey}
)

Vzorový kód pre sastoken:

# get access token for keyvault resource
# you can also use full audience here like https://vault.azure.net
sasToken = notebookutils.credentials.getSecret("<vaultURI>", "<secretName>")
notebookutils.fs.mount(  
    "abfss://mycontainer@<accountname>.dfs.core.windows.net",  
    "/test",  
    {"sasToken":sasToken}
)

Parametre pripojenia:

• fileCacheTimeout: Objekty BLOB sú predvolene uložené vo vyrovnávacej pamäti v miestnom dočasnom priečinku na 120 sekúnd. Počas tohto obdobia objekt blobfuse nekontroluje, či je súbor aktualizovaný alebo nie. Parameter možno nastaviť tak, aby sa zmenil predvolený časový parameter. Ak viacerí klienti upravujú súbory v rovnakom čase, odporúčame skrátiť čas vyrovnávacej pamäte alebo dokonca zmeniť ho na 0 a vždy získať z servera najnovšie súbory.
• časový limit: Časový limit operácie pripojenia je predvolene 120 sekúnd. Parameter možno nastaviť tak, aby sa zmenil predvolený časový parameter. Keď je príliš veľa spustiteľných vykonaní, alebo keď unikne čas pripojenia, odporúča sa zvýšiť hodnotu.

Nasledujúce parametre môžete použiť:

notebookutils.fs.mount(
   "abfss://mycontainer@<accountname>.dfs.core.windows.net",
   "/test",
   {"fileCacheTimeout": 120, "timeout": 120}
)

Ako pripojiť lakehouse

Vzorový kód pre montáž jazera do /<mount_name>:

notebookutils.fs.mount( 
 "abfss://<workspace_name>@onelake.dfs.fabric.microsoft.com/<lakehouse_name>.Lakehouse", 
 "/<mount_name>"
)

Prístup k súborom pod bodom pripojenia pomocou rozhrania notebookutils fs API

Hlavným účelom operácie pripojenia je umožniť zákazníkom prístup k údajom uloženým vo vzdialenom konte úložiska s lokálnym rozhraním API systému súborov. K údajom môžete získať prístup aj pomocou rozhrania API notebookutils fs s pripevnenou cestou ako parameter. Tento formát cesty je trochu iný.

Predpokladajme, že ste pomocou rozhrania API na pripojenie pripojili kontajner Data Lake Storage Gen2 ku kontajneru /test. Keď pristupujete k údajom pomocou rozhrania API lokálneho systému súborov, formát cesty je takýto:

/synfs/notebook/{sessionId}/test/{filename}

Ak chcete získať prístup k údajom pomocou rozhrania API notebookutils fs, odporúčame použiť funkciu getMountPath(), aby ste získali presnú cestu:

path = notebookutils.fs.getMountPath("/test")

• Zoznam adresárov:

  notebookutils.fs.ls(f"file://{notebookutils.fs.getMountPath('/test')}")
  

• Čítať obsah súboru:

  notebookutils.fs.head(f"file://{notebookutils.fs.getMountPath('/test')}/myFile.txt")
  

• Vytvorte adresár:

  notebookutils.fs.mkdirs(f"file://{notebookutils.fs.getMountPath('/test')}/newdir")
  

Prístup k súborom pod bodom pripojenia cez lokálnu cestu

Súbory môžete jednoducho čítať a zapisovať do bodu pripojenia pomocou štandardného systému súborov. Tu je príklad jazyka Python:

#File read
with open(notebookutils.fs.getMountPath('/test2') + "/myFile.txt", "r") as f:
    print(f.read())
#File write
with open(notebookutils.fs.getMountPath('/test2') + "/myFile.txt", "w") as f:
    print(f.write("dummy data"))

Kontrola existujúcich bodov pripojenia

Rozhranie notebookutils.fs.mounts() API môžete použiť na kontrolu všetkých existujúcich informácií o bode pripojenia:

notebookutils.fs.mounts()

Ako zrušiť pripojenie bodu pripojenia

Na zrušenie pripojenia použite nasledujúci kód (/test v tomto príklade):

notebookutils.fs.unmount("/test")

Známe obmedzenia

• Aktuálna konfigurácia na úrovni úlohy; Odporúčame použiť rozhranie API konektorov na kontrolu, či bod pripojenia existuje alebo nie je k dispozícii.

• Mechanizmus unmount sa nepoužije automaticky. Po dokončení spustenia aplikácie musíte explicitne zavolať rozhranie API na zrušenie pripojenia a uvoľniť miesto na disku. V opačnom prípade bude bod pripojenia po dokončení spustenia aplikácie naďalej existovať v uzli.

• Montáž konta úložiska ADLS Gen1 nie je podporovaná.

Služby Lakehouse

notebookutils.lakehouse poskytuje pomôcky prispôsobené pre správu položiek Lakehouse. Tieto pomôcky vám umožňujú vytvárať, získavať, aktualizovať a odstraňovať artefakty služby Lakehouse bez námahy.

Prehľad metód

Tu je prehľad dostupných metód poskytovaných notebookutils.lakehouse:

# Create a new Lakehouse artifact
create(name: String, description: String = "", definition: ItemDefinition = null, workspaceId: String = ""): Artifact

# Retrieve a Lakehouse artifact
get(name: String, workspaceId: String = ""): Artifact

# Get a Lakehouse artifact with properties
getWithProperties(name: String, workspaceId: String = ""): Artifact

# Update an existing Lakehouse artifact
update(name: String, newName: String, description: String = "", workspaceId: String = ""): Artifact

# Delete a Lakehouse artifact
delete(name: String, workspaceId: String = ""): Boolean 

# List all Lakehouse artifacts
list(workspaceId: String = "", maxResults: Int = 1000): Array[Artifact]

# List all tables in a Lakehouse artifact
listTables(lakehouse: String, workspaceId: String = "", maxResults: Int = 1000): Array[Table] 

# Starts a load table operation in a Lakehouse artifact
loadTable(loadOption: collection.Map[String, Any], table: String, lakehouse: String, workspaceId: String = ""): Array[Table] 

Príklady používania

Ak chcete efektívne využiť tieto metódy, zvážte nasledujúce príklady používania:

Vytvorenie služby Lakehouse

artifact = notebookutils.lakehouse.create("artifact_name", "Description of the artifact", "optional_workspace_id")

Získanie Lakehouse

artifact = notebookutils.lakehouse.get("artifact_name", "optional_workspace_id")

artifact = notebookutils.lakehouse.getWithProperties("artifact_name", "optional_workspace_id")

Aktualizácia služby Lakehouse

updated_artifact = notebookutils.lakehouse.update("old_name", "new_name", "Updated description", "optional_workspace_id")

Odstránenie jazera

is_deleted = notebookutils.lakehouse.delete("artifact_name", "optional_workspace_id")

Uvedenie domov lakehouse v pracovnom priestore

artifacts_list = notebookutils.lakehouse.list("optional_workspace_id")

Uvedenie všetkých tabuliek v Lakehouse

artifacts_tables_list = notebookutils.lakehouse.listTables("artifact_name", "optional_workspace_id")

Spustenie operácie načítania tabuľky v službe Lakehouse

notebookutils.lakehouse.loadTable(
    {
        "relativePath": "Files/myFile.csv",
        "pathType": "File",
        "mode": "Overwrite",
        "recursive": False,
        "formatOptions": {
            "format": "Csv",
            "header": True,
            "delimiter": ","
        }
    }, "table_name", "artifact_name", "optional_workspace_id")

Ďalšie informácie

Podrobné informácie o každej metóde a jej parametroch získate v téme o funkcii notebookutils.lakehouse.help("methodName") .

Pomôcky modulu runtime

Zobrazenie kontextovej informácie relácie

Vďaka notebookutils.runtime.context službe môžete získať kontextové informácie o aktuálnej živej relácii vrátane názvu poznámkového bloku, predvoleného prostredia jazera, informácií o pracovnom priestore, spustenia kanála atď.

notebookutils.runtime.context

Správa relácií

Zastavenie interaktívnej relácie

Namiesto manuálneho kliknutia na tlačidlo zastaviť niekedy je pohodlnejšie zastaviť interaktívnu reláciu volaním rozhrania API v kóde. V takýchto prípadoch poskytujeme notebookutils.session.stop() rozhrania API na podporu zastavenia interaktívnej relácie prostredníctvom kódu, ktorý je k dispozícii pre Scala a PySpark.

notebookutils.session.stop()

notebookutils.session.stop() rozhranie API zastaví aktuálnu interaktívnu reláciu asynchrónne na pozadí. Zastaví sa tiež relácia Spark a zdroje na uvoľnenie obsadené reláciou, takže sú k dispozícii pre ostatné relácie v tom istom fonde.

Reštartovanie interpreta jazyka Python

notebookutils.session nástroj poskytuje spôsob, ako reštartovať tlmočníka jazyka Python.

notebookutils.session.restartPython()

Známy problém

• Pri použití verzie runtime vyššie ako 1.2 a spustení notebookutils.help()funkcie , uvedené tkaninyKlient, nie sú teraz podporované rozhrania PBIClient API, budú k dispozícii ďalej. Okrem toho rozhranie API poverení nie je zatiaľ podporované v poznámkových blokoch Scala.

• Poznámkový blok v jazyku Python nepodporuje zastaviť, reštartovať rozhrania API aplikácie Python pri použití pomôcky notebookutils.session na spravovanie relácie.

Súvisiaci obsah

• Microsoft Spark Utilities (MSSparkUtils) pre Fabric
• Vývoj, spúšťanie a spravovanie poznámkových blokov služby Microsoft Fabric
• Spravovanie a spúšťanie poznámkových blokov v službe Fabric s rozhraniami API