Microsoft Fabric : télécharger un fichier dans un Lakehouse avec run()

Dans le premier article, nous avons préparé nb_common et utilisé %run pour récupérer ses constantes et ses petites fonctions dans nb_main_prun.

Nous allons maintenant faire quelque chose d'un peu plus concret : télécharger le fichier games.csv depuis GitHub et le déposer dans le Lakehouse. Cette fois, nous n'allons pas injecter du code dans le notebook principal. Nous allons lancer un autre notebook comme un traitement, lui passer un paramètre et récupérer une information à la fin.

C'est exactement le rôle de notebookutils.notebook.run().

Un notebook de traitement

Créons d'abord un nouveau notebook nommé nb_treatment_run. Son rôle sera très simple : il reçoit le nom d'un dataset, télécharge le CSV correspondant et l'écrit dans le Lakehouse.

Nous allons d'abord créer une cellule de paramètres :

dataset_name = "games"

Dans Fabric, ouvrez le menu … de cette cellule puis choisissez Toggle parameter cell. Les valeurs définies ici seront utilisées si nous exécutons directement le notebook. Elles pourront être remplacées lorsque le notebook sera appelé avec run().

Réutiliser nb_common

Le traitement a besoin de connaître l'URL du fichier et son chemin cible. Ces informations existent déjà dans nb_common, nous allons donc le charger :

%run nb_common

nb_treatment_run possède son propre contexte. Le fait que nb_main_prun ait utilisé %run dans le premier article ne lui transmet pas automatiquement les fonctions et les constantes. Chaque notebook qui en a besoin charge donc nb_common pour lui-même.

Télécharger le fichier

Ajoutons ensuite la cellule qui fait le traitement :

import os
import requests

dataset_config = get_dataset(dataset_name)
target_file_path = f"/lakehouse/default/{dataset_config['target_path']}"

os.makedirs(os.path.dirname(target_file_path), exist_ok=True)

response = requests.get(dataset_config["source_url"])
with open(target_file_path, "wb") as target_file:
    target_file.write(response.content)

log_info(f"Downloaded {dataset_name} to {dataset_config['target_path']}")

Le code est volontairement simple car l'objectif n'est pas sur celui-ci. nous allons donc dans l'ordre :

1. Retrouver l'URL GitHub et le chemin du fichier avec get_dataset() ;
2. Créer le dossier cible dans le Lakehouse ;
3. Télécharger le fichier ;
4. Ecrire le CSV au bon endroit.

À ce stade, nous ne créons ni table Delta, ni DataFrame Spark, ni contrôle de qualité. Le but de cet article est uniquement de comprendre comment run() déclenche un traitement paramétré.

Attention, Il n'y a aucun contrôle d'erreur dasn ce code et le log n'est qu'un simple print qui affiche tout le temps le message d'info ! Dans un vrai notebook de production il faudrait évidement faire un test de réussite et afficher un log ou erreur en conséquence.

Renvoyer un résultat

Le notebook enfant peut renvoyer une chaîne au notebook qui l'appelle. Ici, le nom du dataset suffit :

notebookutils.notebook.exit(dataset_name)

Comme %run, run() référence le notebook par son nom dans le workspace. Mais les deux mécanismes ne font pas du tout la même chose : run() ne nous donne pas accès aux variables ou aux fonctions créées dans le notebook enfant. Il renvoit uniquement la valeur transmise à exit().

Appeler le traitement depuis nb_main_run

Créons maintenant nb_main_run. Nous gardons %run nb_common dans une première cellule pour pouvoir utiliser log_info(). La seconde cellule lance le traitement :

result = notebookutils.notebook.run(
    "nb_treatment_run",
    90,
    {"dataset_name": "games"},
)

log_info(f"Completed dataset: {result}")

Le 90 est le délai maximal, en secondes, accordé au traitement. Le dictionnaire contient les paramètres envoyés au notebook enfant. Ici, dataset_name remplace la valeur par défaut "games" de sa cellule de paramètres.

Le résultat reçu dans result est la chaîne envoyée par notebookutils.notebook.exit(), donc simplement games.

En résumé

run() est utile lorsque nous voulons lancer un notebook de traitement avec des paramètres. Le traitement s’exécute dans son propre contexte, écrit un fichier dans le Lakehouse, puis renvoie une valeur au notebook qui l’a appelé.

Dans cet exemple, nous avons téléchargé un seul fichier. Pour en télécharger deux avec run(), il faudrait lancer deux appels, éventuellement dans une boucle pour simplifier le code. Les traitements s’exécuteraient alors l’un après l’autre.

Dans le prochain article, nous réutiliserons exactement ce même nb_treatment_run pour télécharger games.csv et platforms.csv en parallèle avec runMultiple().