Utilità di Microsoft Spark (MSSparkUtils) per Fabric

Microsoft Spark Utilities (MSSparkUtils) è un pacchetto integrato che ti aiuta a svolgere facilmente compiti comuni. Usare MSSparkUtils per lavorare con i file system, ottenere variabili di ambiente, concatenare notebook e usare i segreti. Il pacchetto MSSparkUtils è disponibile nei notebook PySpark (Python), Scala e SparkR, nonché nelle pipeline di Fabric.

Nota

  • MsSparkUtils è ufficialmente rinominato NotebookUtils. Il codice esistente rimarrà compatibile con le versioni precedenti e non causerà modifiche di rilievo. Raccomandiamo vivamente di aggiornare a notebookutils per garantire supporto continuo e accesso a nuove funzionalità. Il namespace mssparkutils verrà dismesso in futuro.
  • NotebookUtils è progettato per funzionare con Spark 3.4 (Runtime v1.2) e versioni successive. Tutte le nuove funzionalità e gli aggiornamenti saranno supportati esclusivamente con lo spazio dei nomi notebookutils d'ora in poi.

Utilità di file system

mssparkutils.fs fornisce utility per lavorare con vari file system, tra cui Azure Data Lake Storage Gen2 e Archiviazione BLOB di Azure. Assicurarsi di configurare l'accesso ad Azure Data Lake Storage Gen2 e Archiviazione BLOB di Azure in modo appropriato.

Usare i comandi seguenti per una panoramica dei metodi disponibili:

from notebookutils import mssparkutils
mssparkutils.fs.help()

Risultato

mssparkutils.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
mv(from: String, to: String, recurse: 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 mssparkutils.fs.help("methodName") for more info about a method.

MSSparkUtils funziona con il file system nello stesso modo delle API Spark. Prendiamo ad esempio mssparkuitls.fs.mkdirs() e l'uso delle case sul lago:

Utilizzo Percorso relativo dalla radice HDFS Percorso assoluto per il file system ABFS Percorso assoluto del file system locale nel nodo driver
Lakehouse non predefinito Non supportato mssparkutils.fs.mkdirs("abfss://<nome_contenitore>@<nome_account_archiviazione>.dfs.core.windows.net/<nuova_dir>") mssparkutils.fs.mkdirs("file:/<nuova_dir>")
Lakehouse predefinito Directory sotto "Files" o "Tabelle": mssparkutils.fs.mkdirs("Files/<new_dir>") mssparkutils.fs.mkdirs("abfss://<nome_contenitore>@<nome_account_archiviazione>.dfs.core.windows.net/<nuova_dir>") mssparkutils.fs.mkdirs("file:/<nuova_dir>")

Elencare file

Per elencare il contenuto di una directory, usare mssparkutils.fs.ls('Percorso della directory'). Ad esempio:

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

Visualizzazione delle proprietà di file

Questo metodo restituisce le proprietà del file, inclusi il nome del file, il percorso del file, la dimensione del file e se si tratta di una cartella o di un file.

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

Creare una nuova cartella

Questo metodo crea la directory specificata se non esiste, e crea eventuali directory genitori necessarie.

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

Copia file

Questo metodo copia un file o una directory e supporta l'attività di copia tra file system.

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

File di copia con prestazioni elevate

Questo metodo offre un modo più rapido per copiare o spostare file, in particolare volumi elevati di dati.

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

Anteprima del contenuto del file

Questo metodo restituisce fino ai primi maxBytes byte del file specificato come stringa codificata in UTF-8.

# Set the second parameter as an integer for the maxBytes to read
mssparkutils.fs.head('file path', <maxBytes>)

Sposta file

Questo metodo sposta un file o una directory e supporta spostamenti tra file system.

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

Scrivere il file

Questo metodo scrive la stringa specificata in un file codificato in UTF-8.

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

Accodare contenuto a un file

Questo metodo accoda la stringa specificata a un file codificato in UTF-8.

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

Nota

Quando usi l'API mssparkutils.fs.append in un for ciclo per scrivere nello stesso file, ti consigliamo di aggiungere un'istruzione sleep di circa 0,5-1 secondo tra le scritture ricorrenti. Il mssparkutils.fs.append funzionamento interno flush dell'API è asincrono, quindi un breve ritardo aiuta a garantire l'integrità dei dati.

Eliminare un file o una directory

Questo metodo rimuove un file o una directory.

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

Montare/smontare cartella

Per maggiori informazioni sull'uso dettagliato, vedi Montaggio e smontaggio del file.

Le utilità del notebook

Usare le utilità per notebook MSSparkUtils per eseguire un notebook o uscire da un notebook con un valore. Usare il comando seguente per ottenere una panoramica dei metodi disponibili:

mssparkutils.notebook.help()

Prodotto:


exit(value: String): Raises NotebookExit Exception -> This method lets you exit a notebook with a value.
run(path: String, timeoutSeconds: int, arguments: Map): String -> This method runs a notebook and returns its exit value.

Nota

Le utility del notebook non si applicano alle definizioni di lavoro Apache Spark (SJD).

Fare riferimento a un notebook

Questo metodo fa riferimento a un notebook e restituisce il relativo valore di uscita. È possibile eseguire chiamate di funzione di annidamento in un notebook in modo interattivo o in una pipeline. Il notebook a cui si fa riferimento viene eseguito nel pool di Spark del notebook che chiama questa funzione.

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

Ad esempio:

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

Un notebook Fabric supporta anche il riferimento ai notebook in più aree di lavoro specificando l'ID area di lavoro.

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

Puoi aprire il link dello snapshot dell'esecuzione di riferimento nell'output della cella. Lo snapshot acquisisce i risultati dell'esecuzione del codice e consente di eseguire facilmente il debug di un'esecuzione di riferimento.

Screenshot che mostra il risultato del run di riferimento.

Screenshot di una schermata con i risultati dell'esecuzione del codice.

Nota

  • Il notebook di riferimento tra aree di lavoro è supportato dal runtime versione 1.2 e successive.
  • Se usi i file sotto le risorse del quaderno, utilizzali mssparkutils.nbResPath nel quaderno di riferimento per assicurarti che punti alla stessa cartella dell'esecuzione interattiva.

Fare riferimento all’esecuzione più notebook in parallelo

Importante

Questa funzionalità è in anteprima.

Il metodo mssparkutils.notebook.runMultiple() consente di eseguire più notebook in parallelo o con una struttura topologica predefinita. L'API utilizza un'implementazione multithread per inviare, codare e monitorare notebook figli che vengono eseguiti su istanze REPL isolate (read-eval-print-loop) all'interno della sessione Spark esistente. I quaderni bambini di riferimento condividono le risorse di calcolo della sessione.

Con mssparkutils.notebook.runMultiple() è possibile:

  • Eseguire più notebook contemporaneamente senza attendere il completamento di ognuno.

  • Specificare le dipendenze e l'ordine di esecuzione per i notebook usando un formato JSON semplice.

  • Ottimizzare l'uso delle risorse di calcolo di Spark e ridurre i costi dei progetti Fabric.

  • Visualizza le snapshot di ogni esecuzione del notebook nell'output ed esegui il debug e monitora facilmente le attività del notebook.

  • Ottenere il valore di uscita di ogni attività esecutiva e usarlo in attività successive.

È anche possibile provare a eseguire mssparkutils.notebook.help("runMultiple") per trovare l'esempio e l'uso dettagliato.

Di seguito è riportato un semplice esempio di esecuzione di un elenco di notebook in parallelo usando questo metodo:


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

Il risultato dell'esecuzione del notebook radice è il seguente:

Screenshot di un elenco di notebook di riferimento.

L'esempio seguente mostra come eseguire notebook con una struttura topologica usando mssparkutils.notebook.runMultiple(). Usare questo metodo per orchestrare facilmente i notebook tramite un'esperienza di programmazione.

# 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, defaults to 50 but ultimately constrained by the number of driver cores
}
mssparkutils.notebook.runMultiple(DAG, {"displayDAGViaGraphviz": False})

Il risultato dell'esecuzione del notebook radice è il seguente:

Screenshot del riferimento a un elenco di notebook con parametri.

Nota

  • Il limite massimo per le attività del notebook o i notebook simultanei è vincolato dal numero di core del driver. Ad esempio, un driver di nodo Medio con otto core può eseguire fino a otto notebook contemporaneamente. Questo limite esiste perché ogni notebook inviato viene eseguito sulla propria istanza REPL (read-eval-print-loop), e ogni istanza consuma un core del driver.
  • Il parametro di concorrenza predefinito è impostato su 50 per supportare il ridimensionamento automatico della concorrenza massima man mano che gli utenti configurano pool di Spark con nodi più grandi e quindi più core driver. Sebbene si possa impostare questo parametro a un valore superiore usando un nodo driver più grande, aumentare il numero di processi concorrenti in esecuzione su un singolo nodo driver di solito non scala linearmente. L'aumento della concorrenza può portare a una riduzione dell'efficienza a causa del conflitto di risorse tra driver e executor. Ogni notebook in esecuzione funziona su un'istanza REPL dedicata che consuma CPU e memoria sul driver. In condizioni di alta concorrenza, questo consumo può aumentare il rischio di instabilità dei driver o errori di perdita di memoria, in particolare per carichi di lavoro di lunga durata.
  • Potresti sperimentare tempi di esecuzione più lunghi per ogni singolo lavoro a causa del sovraccarico di inizializzare istanze REPL e orchestrare molti notebook. Se dovessero sorgere problemi, valuta di separare i notebook in chiamate multiple runMultiple o di ridurre la concorrenza regolando il campo concurrency nel parametro DAG.
  • Quando si eseguono notebook di breve durata (ad esempio, 5 secondi di esecuzione del codice), il sovraccarico di inizializzazione diventa dominante. La variabilità nei tempi di preparazione potrebbe ridurre la probabilità di sovrapposizione dei quaderni e quindi portare a una minore concorrenza realizzata. In questi scenari, potrebbe essere più ottimale combinare piccole operazioni in uno o più notebook.
  • Sebbene il multithreading venga utilizzato per l'invio, l'accodamento e il monitoraggio, tieni presente che il codice eseguito in ogni notebook non viene eseguito in modalità multithread in ciascun esecutore. Non c'è condivisione delle risorse tra quaderni. A ogni processo del notebook viene assegnata una parte delle risorse totali dell'esecutore. Questa allocazione può far sì che i processi più brevi vengano eseguiti in modo inefficiente e che quelli più lunghi si contendano le risorse.
  • Il timeout predefinito per l'intero DAG è di 12 ore, e il timeout predefinito per ogni cella nei notebook bambini è di 90 secondi. È possibile modificare il timeout impostando i campi timeoutInSeconds e timeoutPerCellInSeconds nel parametro DAG. Man mano che aumenti la concorrenza, potresti dover aumentare il timeoutPerCellInSeconds per evitare che possibili contesi sulle risorse causino timeout inutili.

Uscire da un notebook

Questo metodo termina un notebook restituendo un valore. È possibile eseguire chiamate di funzione di annidamento in un notebook in modo interattivo o in una pipeline.

  • Quando si chiama una funzione exit() da un notebook in modo interattivo, il notebook Fabric genera un'eccezione, ignora l'esecuzione delle celle successive e mantiene attiva la sessione Spark.

  • Quando si orchestra un notebook in una pipeline che chiama una funzione exit(), l'attività del notebook restituisce un valore di uscita, completa l'esecuzione della pipeline e arresta la sessione Spark. Non racchiudere la funzione exit() attorno a un try/catch poiché questa eccezione NotebookExit deve propagarsi affinché la pipeline ottenga il valore di ritorno.

  • Quando si chiama una funzione exit() in un notebook a cui viene fatto riferimento, Fabric Spark interrompe l'ulteriore esecuzione del notebook richiamato e continua a eseguire le celle successive nel notebook principale che chiama la funzione run(). Esempio: Notebook1 ha tre celle e chiama una funzione exit() nella seconda cella. Notebook2 ha cinque celle e chiama run(notebook1) nella terza cella. Quando si esegue Notebook2, Notebook1 si arresta nella seconda cella quando si raggiunge la funzione exit(). Notebook2 sta continuando a eseguire la quarta e la quinta cella.

mssparkutils.notebook.exit("value string")

Ad esempio:

Notebook Sample1 con le due celle seguenti:

  • La cella 1 definisce un parametro di input con il valore predefinito impostato su 10.

  • La cella 2 esce dal notebook con input come valore di uscita.

Screenshot che mostra un notebook di esempio della funzione di uscita.

È possibile eseguire Sample1 in un altro notebook con i valori predefiniti:

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

Prodotto:

Notebook executed successfully with exit value 10

È possibile eseguire Sample1 in un altro notebook e impostare il valore di input su 20:

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

Prodotto:

Notebook executed successfully with exit value 20

Utilità delle credenziali

Puoi usare le Utility delle Credenziali di MSSparkUtils per ottenere token di accesso e gestire segreti in Azure Key Vault.

Usare il comando seguente per ottenere una panoramica dei metodi disponibili:

mssparkutils.credentials.help()

Prodotto:

getToken(audience, name): returns AAD token for a given audience, name (optional)
getSecret(keyvault_endpoint, secret_name): returns secret for a given Key Vault and secret name

Ottenere un token

getTokenrestituisce un token Microsoft Entra per un determinato pubblico e nome (opzionale). L'elenco seguente mostra le chiavi del pubblico attualmente disponibili:

  • Risorsa per il pubblico di archiviazione: storage
  • Risorsa Power BI:pbi
  • Azure Key Vault Resource:keyvault
  • Risorsa DB KQL Synapse RTA: kusto

Usare il comando seguente per ottenere il token:

mssparkutils.credentials.getToken('audience Key')

Ottenere il segreto usando le credenziali degli utenti

getSecretrestituisce un segreto di Azure Key Vault per un dato endpoint Azure Key Vault e un nome segreto usando le credenziali utente.

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

Montaggio e smontaggio di file

Fabric supporta gli scenari di montaggio seguenti nel pacchetto di utilità di Microsoft Spark. Puoi usare le API mount, unmount, getMountPath() e mounts() per collegare lo storage remoto (Azure Data Lake Storage Gen2) a tutti i nodi funzionanti (nodo driver e nodo work). Dopo aver creato il punto di montaggio della memoria, utilizzare l'API dei file locali per accedere ai dati come se fossero archiviati nel file system locale.

Come montare un account di Azure Data Lake Storage Gen2

Il seguente esempio mostra come montare Azure Data Lake Storage Gen2. Il montaggio di gestione rete virtuale di Azure funziona in modo analogo.

Questo esempio presuppone che si disponga di un account Data Lake Storage Gen2 denominato storegen2 e che l'account abbia un contenitore denominato mycontainer che si vuole montare in /test nella sessione Spark del notebook.

Screenshot che mostra dove selezionare un contenitore da montare.

Per montare il contenitore chiamato mycontainer, mssparkutils verifica prima se hai il permesso di accedere al container. Fabric supporta tre metodi di autenticazione per l'operazione di montaggio del trigger: token Microsoft Entra (predefinito e consigliato), accountKey e sastoken. Per maggiori informazioni sull'autenticazione tramite token di Microsoft Entra e sull'attuale notebookutils API, consulta NotebookUtils: montaggio e smontaggio di file per Fabric.

Montare utilizzando un token di firma di accesso condivisato o una chiave di account

MSSparkUtils supporta il passaggio esplicito di una chiave dell'account o di un token di firma di accesso condiviso (SAS) come parametro per montare la destinazione.

Per motivi di sicurezza, è consigliabile archiviare le chiavi dell'account o i token di firma di accesso condiviso (SAS) in Azure Key Vault, come illustrato nello screenshot seguente. È quindi possibile recuperarli usando l'API mssparkutils.credentials.getSecret. Per altre informazioni su Azure Key Vault, vedere Informazioni sulle chiavi dell'account di archiviazione gestito di Azure Key Vault.

Screenshot che mostra dove vengono archiviati i segreti in Azure Key Vault.

Codice di esempio per il metodo accountKey:

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

Codice di esempio per sastoken:

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

Nota

Potrebbe essere necessario importare mssparkutils se non è disponibile:

from notebookutils import mssparkutils

Parametri di montaggio:

  • fileCacheTimeout: I blob si cachettano nella cartella temporanea locale per 120 secondi di default. Durante questo periodo blobfuse non controlla se il file è aggiornato. Imposta questo parametro per cambiare il timeout predefinito. Quando più client modificano i file contemporaneamente, per evitare incongruenze tra file locali e remoti, consigliamo di ridurre il tempo di cache, o addirittura di cambiarlo a 0, e di ottenere sempre i file più recenti dal server.
  • timeout: Il timeout per l'operazione di montatura è di default 120 secondi. Imposta questo parametro per cambiare il timeout predefinito. Quando ci sono troppi executor o quando il montaggio va in timeout, consigliamo di aumentare il valore.

È possibile usare questi parametri come indicato di seguito:

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

Nota

Per motivi di sicurezza, non archiviare le credenziali nel codice. Per proteggere ulteriormente le tue credenziali, il segreto viene oscurato nell'output del notebook. Per ulteriori informazioni, vedere Redazione dei segreti.

Come montare un lakehouse

Esempio di codice per montare una casa sul lago su /test:

from notebookutils import mssparkutils 
mssparkutils.fs.mount( 
 "abfss://<workspace_id>@onelake.dfs.fabric.microsoft.com/<lakehouse_id>", 
 "/test"
)

Nota

Non è supportato il montaggio di un endpoint regionale. Fabric supporta solo il montaggio dell'endpoint globale, onelake.dfs.fabric.microsoft.com.

Accedi ai file sotto il punto di montatura usando l'API fs di mssparkutils

Lo scopo principale dell'operazione di montaggio è permetterti di accedere ai dati memorizzati in un account di archiviazione remota utilizzando un'API locale del file system. È anche possibile accedere ai dati usando l'API mssparkutils fs con un percorso montato come parametro. Questo formato di percorso è lievemente diverso.

Supponiamo di aver montato il container mycontainer/test di Data Lake Storage Gen2 usando l'API mount. Quando accedi ai dati utilizzando un'API locale del file system, il formato del percorso è il seguente:

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

Quando vuoi accedere ai dati usando l'API fs di mssparkutils , ti consigliamo di usare getMountPath() per ottenere il percorso accurato:

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

  • Elencare directory:

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

  • Leggere il contenuto del file:

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

  • Creare una directory:

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

Accedere ai file nel punto di montaggio tramite il percorso locale

È possibile leggere e scrivere facilmente i file nel punto di montaggio usando il file system standard. Di seguito è riportato un esempio in Python:

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

Come controllare i punti di montaggio esistenti

È possibile usare l'API mssparkutils.fs.mounts() per controllare tutte le informazioni sui punti di montaggio esistenti:

mssparkutils.fs.mounts()

Come smontare il punto di montaggio

Usare il codice seguente per smontare il punto di montaggio (/test in questo esempio):

mssparkutils.fs.unmount("/test")

Limitazioni note

  • Il montaggio corrente è una configurazione a livello di job. Ti consigliamo di usare l'API mounts per verificare se esiste o meno un punto di montaggio.

  • Il meccanismo di smontaggio non è automatico. Al termine dell'esecuzione dell'applicazione, per smontare il punto di montaggio e rilasciare lo spazio su disco, è necessario chiamare in modo esplicito un'API di smontaggio nel codice. In caso contrario, il punto di montaggio esiste ancora nel nodo al termine dell'esecuzione dell'applicazione.

  • Non è supportato il montaggio di un account di archiviazione Azure Data Lake Storage Gen1.

Utilità di Lakehouse

Il mssparkutils.lakehouse modulo fornisce le utilità per la gestione degli articoli della casa del lago. Queste utility rendono facile creare, recuperare, aggiornare ed eliminare elementi di lakehouse.

Nota

Le API di Lakehouse sono supportate solo su Runtime versione 1.2 o successiva.

Panoramica dei metodi

I seguenti metodi sono disponibili nel mssparkutils.lakehouse modulo:

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

# Retrieve a Lakehouse artifact
get(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 = ""): Array[Artifact]

Esempi di utilizzo

Per utilizzare efficacemente questi metodi, considera i seguenti esempi d'uso:

Creare un oggetto di casa sul lago

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

Recupero di un oggetto della casa sul lago

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

Aggiornare un elemento di una casa sul lago

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

Eliminazione di un elemento della casa sul lago

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

Elenco degli oggetti della casa sul lago

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

Informazioni aggiuntive

Per informazioni più dettagliate su ciascun metodo e i suoi parametri, usa la mssparkutils.lakehouse.help("methodName") funzione.

Utilizzando le utility Lakehouse di MSSparkUtils, puoi gestire in modo più efficiente i tuoi articoli lakehouse e integrare questa gestione nelle pipeline Fabric, migliorando così la tua esperienza complessiva di gestione dei dati.

Esplora queste utilità e incorporale nei tuoi flussi di lavoro Fabric per una gestione fluida degli articoli a lakehouse.

Utilità di runtime

Visualizzare informazioni contestuali della sessione

Utilizzando mssparkutils.runtime.context, puoi ottenere le informazioni di contesto per la sessione live corrente, incluso il nome del notebook, il lakehouse predefinito, le informazioni sull'area di lavoro, se si tratta di un'esecuzione di pipeline e altro ancora.

mssparkutils.runtime.context

Nota

mssparkutils.envNon è ufficialmente supportato su Fabric. Usare notebookutils.runtime.context come alternativa.

Problema noto

Quando usi una versione runtime successiva alla 1.2 e la esegui mssparkutils.help(), le API di fabricClient, warehouse e workspace elencate non sono attualmente supportate.

Contenuto correlato

  • Last updated on