Utilidades de Microsoft Spark (MSSparkUtils) para Fabric

Las utilidades de Spark para Microsoft (MSSparkUtils) son un paquete integrado que le ayuda a realizar las tareas más comunes con mayor facilidad. Puede usar MSSparkUtils para trabajar con sistemas de archivos, obtener variables de entorno, encadenar cuadernos entre sí y trabajar con secretos. El paquete MSSparkUtils está disponible en PySpark (Python) Scala, cuadernos de SparkR y canalizaciones de Fabric.

Nota:

• MsSparkUtils ha cambiado oficialmente el nombre a NotebookUtils. El código existente seguirá siendo compatible con versiones anteriores y no provocará cambios importantes. Se recomienda encarecidamente actualizar a notebookutils para garantizar el soporte y el acceso continuos a las nuevas características. El espacio de nombres mssparkutils se retirará en el futuro.
• NotebookUtils está diseñado para funcionar con Spark 3.4(Runtime v1.2) y versiones posteriores. Todas las nuevas características y actualizaciones se admitirán exclusivamente con el espacio de nombres notebookutils en el futuro.

Utilidades del sistema de archivos

mssparkutils.fs ofrece utilidades para trabajar con varios sistemas de archivos, como Azure Data Lake Storage Gen2 (ADLS) Gen2 y Azure Blob Storage. Asegúrese de configurar el acceso a Azure Data Lake Storage Gen2 y Azure Blob Storage adecuadamente.

Ejecute los siguientes comandos para obtener información general sobre los métodos disponibles:

from notebookutils import mssparkutils
mssparkutils.fs.help()

Salida

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 funciona con el sistema de archivos de la misma manera que las API de Spark. Tomemos como ejemplo mssparkuitls.fs.mkdirs() y el uso del almacén de lago de Fabric:

Uso	Ruta de acceso relativa desde la raíz de HDFS	Ruta de acceso absoluta para el sistema de archivos ABFS	Ruta de acceso absoluta para el sistema de archivos local en el nodo del driver
Lakehouse no predeterminado	No compatible	mssparkutils.fs.mkdirs("abfss://<container_name>@<storage_account_name>.dfs.core.windows.net/<new_dir>")	mssparkutils.fs.mkdirs("file:/<new_dir>")
Lakehouse predeterminado	Directorio en "Files" o "Tables": mssparkutils.fs.mkdirs("Files/<new_dir>")	mssparkutils.fs.mkdirs("abfss://<container_name>@<storage_account_name>.dfs.core.windows.net/<new_dir>")	mssparkutils.fs.mkdirs("file:/<new_dir>")

Enumerar archivos

Para enumerar el contenido de un directorio, use mssparkutils.fs.ls("Ruta de acceso del directorio"). Por ejemplo:

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 

Vea las propiedades del archivo.

Este método devuelve las propiedades del archivo, incluido el nombre, la ruta de acceso, el tamaño y si es un directorio o un archivo.

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

Creación de un directorio

Este método crea el directorio especificado si no existe y también crea los directorios principales necesarios.

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 

Copiar archivo

Este método copia un archivo o directorio y admite la actividad de copia entre sistemas de archivos.

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

Copiar archivos de un modo más eficaz

Este método proporciona una manera más rápida de copiar o mover archivos, especialmente grandes volúmenes de datos.

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

Vista previa del contenido del archivo

Este método devuelve hasta los primeros "maxBytes" bytes del archivo especificado como una cadena codificada en UTF-8.

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

Mover archivo

Este método mueve un archivo o directorio y admite movimientos entre sistemas de archivos.

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.

Escritura de archivos

Este método escribe la cadena especificada en un archivo, codificada en formato 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

Adición de contenido a un archivo

Este método anexa la cadena especificada a un archivo, codificada en formato 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:

Al usar la API de mssparkutils.fs.append en un bucle de for para escribir en el mismo archivo, se recomienda agregar una instrucción sleep de alrededor de 0,5s~1s entre las escrituras periódicas. Esto se debe a que la operación flush interna de la API de mssparkutils.fs.append es asincrónica, por lo que un breve retraso ayuda a garantizar la integridad de los datos.

Eliminación de un archivo o directorio

Este método quita un archivo o directorio.

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

Montaje o desmontaje del directorio

Obtenga más información sobre el uso detallado en Montaje y desmontaje de archivos.

Utilidades de cuaderno

Use las utilidades de cuaderno MSSparkUtils para ejecutar un cuaderno o salir de uno con un valor. Ejecute el siguiente comando para obtener información general sobre los métodos disponibles:

mssparkutils.notebook.help()

Salida:

exit(value: String): void -> 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:

Las utilidades de cuaderno no son aplicables a las definiciones de trabajo de Apache Spark (SJD).

Referencia a un cuaderno

Este método hace referencia a un cuaderno y devuelve su valor de salida. Puede ejecutar llamadas de función anidadas en un cuaderno de manera interactiva o en una canalización. El cuaderno al que se hace referencia se ejecuta en el grupo de Spark del cuaderno que llama a esta función.

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

Por ejemplo:

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

El cuaderno de Fabric también admite la referencia a cuadernos en varias áreas de trabajo especificando el ID del área de trabajo.

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

Puede abrir el vínculo de instantánea de la ejecución de referencia en la salida de la celda. La instantánea captura los resultados de la ejecución del código y permite depurar fácilmente una ejecución de referencia.

Nota:

• El cuaderno de referencia entre áreas de trabajo es compatible con la versión 1.2 y posteriores del tiempo de ejecución.
• Si utiliza los archivos en Recurso de cuaderno, use mssparkutils.nbResPath en el cuaderno al que se hace referencia para asegurarse de que apunta a la misma carpeta que la ejecución interactiva.

Referencia que ejecuta varios cuadernos en paralelo

Importante

Esta característica se encuentra en versión preliminar.

El método mssparkutils.notebook.runMultiple() permite ejecutar varios cuadernos en paralelo o con una estructura topológica predefinida. La API utiliza un mecanismo de implementación de varios subprocesos dentro de una sesión de Spark, lo que significa que los recursos de proceso se comparten mediante las ejecuciones del cuaderno de referencia.

Con mssparkutils.notebook.runMultiple(), puede:

• Ejecute varios cuadernos simultáneamente, sin esperar a que finalice cada uno.

• Especifique las dependencias y el orden de ejecución de los cuadernos mediante un formato JSON simple.

• Optimice el uso de recursos de proceso de Spark y reduzca el costo de los proyectos de Fabric.

• Vea las instantáneas de cada registro de ejecución de cuadernos en la salida y depure o supervise las tareas del cuaderno de forma cómoda.

• Obtenga el valor de salida de cada actividad ejecutiva y úselos en tareas descendentes.

También puede intentar ejecutar mssparkutils.notebook.help("runMultiple") para buscar el ejemplo y el uso detallado.

Este es un ejemplo sencillo de ejecutar una lista de cuadernos en paralelo mediante este método:

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

El resultado de la ejecución del cuaderno raíz es el siguiente:

A continuación se muestra un ejemplo de ejecución de cuadernos con estructura topológica mediante mssparkutils.notebook.runMultiple(). Use este método para organizar fácilmente cuadernos a través de una experiencia de código.

# 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
}
mssparkutils.notebook.runMultiple(DAG, {"displayDAGViaGraphviz": False})

El resultado de la ejecución del cuaderno raíz es el siguiente:

Nota:

• El grado de paralelismo de la ejecución de varios cuadernos está restringido al recurso de proceso total disponible de una sesión de Spark.
• El límite superior de actividades de cuadernos o cuadernos simultáneos es de 50. Superar este límite puede provocar problemas de estabilidad y rendimiento debido a un uso elevado de recursos de proceso. Si surgen problemas, considere la posibilidad de separar cuadernos en varias llamadas de runMultiple o reducir la simultaneidad ajustando el campo de simultaneidad en el parámetro DAG.
• El tiempo de expiración predeterminado para el DAG completo es de 12 horas y el tiempo de expiración predeterminado para cada celda del cuaderno secundario es de 90 segundos. Puede cambiar el tiempo de expiración definiendo los campos timeoutInSeconds y timeoutPerCellInSeconds en el parámetro DAG.

Salida de un cuaderno

Este método sale de un cuaderno con un valor. Puede ejecutar llamadas de función anidadas en un cuaderno de manera interactiva o en una canalización.

• Cuando llama a una función exit() desde un cuaderno de forma interactiva, el cuaderno de Fabric generará una excepción, omitirá la ejecución de celdas de subsecuencia y mantendrá activa la sesión de Spark.

• Cuando se orquesta un cuaderno en una canalización que llama a una función exit(), la actividad de cuaderno vuelve con un valor de salida, completa la ejecución de canalización y detiene la sesión de Spark.

• Cuando se llama a una función exit() en un cuaderno al que se está haciendo referencia, Fabric Spark detendrá la ejecución posterior del cuaderno al que se hace referencia y continuará ejecutando las siguientes celdas en el cuaderno principal que llama a la función run(). Por ejemplo: Notebook1 tiene tres celdas y llama a una función exit() en la segunda celda. Notebook2 tiene cinco celdas y llama a run(notebook1) en la tercera celda. Al ejecutar Notebook2, Notebook1 se detiene en la segunda celda al pulsar la función exit(). Notebook2 continua con la ejecución de su cuarta y quinta celda.

mssparkutils.notebook.exit("value string")

Por ejemplo:

El cuaderno Sample1 con las dos celdas siguientes:

• La celda 1 define un parámetro input con un valor predeterminado establecido en 10.

• La celda 2 sale del cuaderno con el valor de input como valor de salida.

Puede ejecutar Sample1 en otro cuaderno con los valores predeterminados:

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

Salida:

Notebook executed successfully with exit value 10

Puede ejecutar Sample1 en otro cuaderno y establecer el valor de input en 20:

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

Salida:

Notebook executed successfully with exit value 20

Utilidades de credenciales

Puede usar las utilidades de credenciales de MSSparkUtils para obtener los tokens de acceso y administrar los secretos en Azure Key Vault.

Ejecute el siguiente comando para obtener información general sobre los métodos disponibles:

mssparkutils.credentials.help()

Salida:

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

Obtener el token

getToken devuelve un token de Microsoft Entra para una audiencia y un nombre determinado (opcional). En la lista siguiente se muestran las claves de público disponibles actualmente:

• Recurso de público de almacenamiento: "storage"
• Recursos de Power BI: "pbi"
• Recurso de Azure Key Vault: "keyvault"
• Recurso de base de datos KQL de Synapse RTA: "kusto"

Ejecute el siguiente comando para obtener el token:

mssparkutils.credentials.getToken('audience Key')

Obtención del secreto con las credenciales de usuario

getSecret devuelve un secreto de Azure Key Vault para un punto de conexión y un nombre de secreto de Azure Key Vault determinados mediante las credenciales del usuario.

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

Montaje y desmontaje de archivos

Fabric admite los siguientes escenarios de montaje en el paquete de utilidades de Microsoft Spark. Puede usar las API mount, unmount, getMountPath() y mounts() para adjuntar almacenamiento remoto (ADLG Gen2) a todos los nodos de trabajo (nodo de driver y nodos de trabajo). Una vez instalado el punto de montaje de almacenamiento, utilice la API de archivos locales para acceder a los datos como si estuvieran almacenados en el sistema de archivos local.

Montaje de una cuenta de ADLS Gen2

En el ejemplo siguiente se muestra cómo montar Azure Data Lake Storage Gen2. El montaje de Blob Storage funciona de forma similar.

En este ejemplo se supone que tiene una cuenta de Data Lake Storage Gen2 denominada storegen2 y que la cuenta tiene un contenedor denominado mycontainer que desea montar en /test en la sesión de Spark del cuaderno.

Para montar el contenedor llamado mycontainer, mssparkutils primero necesita comprobar si tiene permiso para acceder al contenedor. Actualmente, Fabric admite dos métodos de autenticación para la operación de montaje del desencadenador: accountKey y sastoken.

Montaje con un token de firma de acceso compartido o una clave de cuenta

MSSparkUtils permite pasar explícitamente una clave de cuenta o firma de acceso compartido (SAS) como parámetro para montar el destino.

Por motivos de seguridad, se recomienda almacenar las claves de cuenta o los tokens de SAS en Azure Key Vault (como se muestra en la siguiente captura de pantalla). A continuación, puede recuperarlos mediante la API mssparkutils.credentials.getSecret API. Para obtener más información sobre Azure Key Vault, consulte Acerca de las claves de cuenta de almacenamiento administradas de Azure Key Vault.

Código de ejemplo para el método 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}
)

Código de ejemplo para 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:

Puede ser necesario que importe mssparkutils si no está disponible:

from notebookutils import mssparkutils

Parámetros de montaje:

• fileCacheTimeout: los blobs se almacenarán en caché en la carpeta temporal local durante 120 segundos de forma predeterminada. Durante este tiempo, blobfuse no comprobará si el archivo está actualizado o no. El parámetro se puede establecer para cambiar el tiempo de espera predeterminado. Cuando varios clientes modifican archivos al mismo tiempo, para evitar incoherencias entre archivos locales y remotos, se recomienda acortar el tiempo de caché o incluso cambiarlo a 0 y obtener siempre los archivos más recientes del servidor.
• timeout: el tiempo de espera de la operación de montaje es de 120 segundos de forma predeterminada. El parámetro se puede establecer para cambiar el tiempo de espera predeterminado. Cuando hay demasiados ejecutores o cuando se agota el tiempo de espera de montaje, se recomienda aumentar el valor.

Puede usar estos parámetros de la siguiente manera:

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

Nota:

Por motivos de seguridad, se recomienda no almacenar credenciales en el código. Para proteger aún más sus credenciales, se censurará el secreto en la salida del cuaderno. Para más información, consulte el artículo sobre redacción de secretos.

Cómo montar un almacén de lago

Código de ejemplo para montar una instancia de Lakehouse en /test:

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

Nota:

No se admite el montaje de un punto de conexión regional. Fabric solo admite el montaje del punto de conexión global, onelake.dfs.fabric.microsoft.com.

Acceso a los archivos del punto de montaje por medio de la API mssparktuils fs

El objetivo principal de la operación de montaje es permitir a los clientes acceder a los datos almacenados en una cuenta de almacenamiento remoto con una API del sistema de archivos local. También puede acceder a los datos por medio de la API mssparkutils fs con una ruta de acceso montada como parámetro. Este formato de ruta de acceso es un poco diferente.

Supongamos que ha montado el contenedor de Data Lake Storage Gen2 mycontainer en /test utilizando la API de montaje. Cuando accede a los datos con la API del sistema de archivos local, el formato de la ruta de acceso es como el siguiente:

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

Cuando quiera acceder a los datos mediante la API mssparkutils fs, se recomienda usar getMountPath() para obtener la ruta de acceso precisa:

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

• Enumerar directorios:

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

• Leer el contenido de archivos:

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

• Crear un directorio:

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

Acceso a los archivos en el punto de montaje a través de la ruta de acceso local

Puede leer y escribir fácilmente los archivos en el punto de montaje mediante el sistema de archivos estándar. Este es un ejemplo de 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"))

Cómo comprobar los puntos de montaje existentes

Puede usar la API mssparkutils.fs.mounts() para comprobar toda la información existente sobre los puntos de montaje:

mssparkutils.fs.mounts()

Desmontaje del punto de montaje.

Use el siguiente código para desmontar el punto de montaje (/test en este ejemplo):

mssparkutils.fs.unmount("/test")

Limitaciones conocidas

• El montaje actual es una configuración de nivel de trabajo; se recomienda usar las API de montajes para comprobar si existe un punto de montaje o no está disponible.

• El mecanismo de desmontaje no es automático. Cuando termine la ejecución de la aplicación, para desmontar el punto de montaje y liberar el espacio en disco, debe llamar explícitamente a una API de desmontaje en el código. De lo contrario, el punto de montaje seguirá existiendo en el nodo cuando termine la ejecución de la aplicación.

• No se admite el montaje de una cuenta de almacenamiento de ADLS Gen1.

Utilidades de Lakehouse

mssparkutils.lakehouse proporciona utilidades adaptadas específicamente para administrar artefactos de Lakehouse. Estas utilidades permiten a los usuarios crear, recuperar, actualizar y eliminar artefactos de Lakehouse sin esfuerzo.

Nota:

Las API de Lakehouse solo se admiten en el tiempo de ejecución versión 1.2 y posteriores.

Información general de los métodos

A continuación se muestra información general de los métodos disponibles proporcionados por mssparkutils.lakehouse:

# 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]

Ejemplos de uso

Para usar estos métodos de forma eficaz, tenga en cuenta los ejemplos de utilización siguientes:

Creación de un artefacto de Lakehouse

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

Recuperación de un artefacto de Lakehouse

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

Actualización de un artefacto de Lakehouse

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

Eliminación de un artefacto de Lakehouse

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

Enumeración de artefactos de Lakehouse

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

Información adicional

Para obtener información más detallada sobre cada método y sus parámetros, utilice la función mssparkutils.lakehouse.help("methodName").

Con las utilidades de Lakehouse de MSSparkUtils, la administración de los artefactos de Lakehouse es más eficaz e integrada en las canalizaciones de Fabric, lo que mejora la experiencia general de administración de datos.

No dude en explorar estas utilidades e incorporarlas en los flujos de trabajo de Fabric para administrar sin problemas los artefactos de Lakehouse.

Utilidades en tiempo de ejecución

Mostrar la información de contexto de sesión

Con mssparkutils.runtime.context puede obtener la información de contexto de la sesión activa actual, incluido el nombre del cuaderno, el almacén de lago predeterminado, la información del área de trabajo, si se trata de una ejecución de canalización, etc.

mssparkutils.runtime.context

Problema conocido

Al usar la versión en tiempo de ejecución anterior a 1.2 y ejecutar mssparkutils.help(), las API fabricClient, almacén y área de trabajo enumeradas no se admiten por ahora; estarán disponibles posteriormente.

Contenido relacionado

• Administración de bibliotecas