Partager via

Développer, exécuter et gérer des notebooks Microsoft Fabric

Un notebook Microsoft Fabric est un élément de code principal pour le développement de travaux Apache Spark et d’expériences de Machine Learning. Il s’agit d’une surface interactive web utilisée par les scientifiques des données et les ingénieurs données pour écrire du code bénéficiant de visualisations enrichies et de texte Markdown. Cet article explique comment développer des notebooks avec des opérations de cellule de code et comment les exécuter.

Développer des notebooks

Les notebooks sont constitués de cellules qui sont des blocs individuels de code ou de texte qui peuvent être exécutés de façon indépendante ou en tant que groupe.

Nous proposons des opérations riches pour développer des notebooks :

Ajouter une cellule

Il existe plusieurs façons d’ajouter une cellule à un bloc-notes.

  1. Placez le curseur sur l’espace entre deux cellules et sélectionnez Code ou Markdown.

  2. Utilisez les touches de raccourci en mode de commande. Appuyez sur A pour insérer une cellule au-dessus de la cellule active. Appuyez sur B pour insérer une cellule en dessous de la cellule active.

Définir un langage principal

Les notebooks Fabric prennent actuellement en charge quatre langages Apache Spark :

  • PySpark (Python)
  • Spark (Scala)
  • Spark SQL
  • SparkR

Vous pouvez définir le langage principal des nouvelles cellules ajoutées dans la liste déroulante de la barre de commandes supérieure.

Utiliser plusieurs langages

Vous pouvez utiliser plusieurs langages dans un carnet en spécifiant la commande langage magique au début d’une cellule. Vous pouvez également changer le langage de la cellule à partir du sélecteur de langage. Le tableau suivant présente les commandes magiques qui permettent de changer la langue des cellules.

Capture d'écran montrant un exemple de commande langage magic introduite au début d'une cellule.

Commande magique Langue Description
%%pyspark Python Exécuter une requête Python sur du contexte Apache Spark.
%%spark Langage de programmation Scala Exécuter une requête Scala sur du contexte Apache Spark.
%%sql SparkSQL Exécuter une requête SparkSQL sur du contexte Apache Spark.
%%html HTML Exécutez n requête HTML sur le contexte Apache Spark.
%%sparkr R Exécuter une requête R sur du contexte Apache Spark.

IntelliSense de style IDE

Les notebooks Fabric sont intégrés à l’éditeur Monaco pour doter l’éditeur de cellule de la fonctionnalité IntelliSense de style IDE. La mise en surbrillance de la syntaxe, le marqueur d’erreurs et la complétion automatique de code vous aident à rapidement écrire du code et identifier les problèmes.

Les fonctionnalités IntelliSense sont à des niveaux de maturité différents pour les différents langages. Le tableau suivant indique ce que Fabric prend en charge :

Langues Mise en surbrillance de la syntaxe Marqueur des erreurs de syntaxe Complétion de code de syntaxe Complétion de code variable Complétion de code de fonction système Complétion de code de fonction utilisateur Retrait intelligent Pliage de code
PySpark (Python) Oui Oui Oui Oui Oui Oui Oui Oui
Python Oui Oui Oui Oui Oui Oui Oui Oui
Spark (Scala) Oui Oui Oui Oui Oui Oui Oui Oui
SparkSQL Oui Oui Oui Oui Oui Non Oui Oui
SparkR Oui Oui Oui Oui Oui Oui Oui Oui
T-SQL Oui Oui Oui Non Oui Oui Oui Oui

Remarque

Vous devez avoir une session Apache Spark active pour utiliser la complétion de code IntelliSense.

Améliorer le développement Python avec Pylance

Remarque

Actuellement, la fonctionnalité est en préversion.

Pylance, un serveur de langage puissant et riche en fonctionnalités, est désormais disponible dans le notebook Fabric. Pylance facilite le développement Python avec des achèvements intelligents, une meilleure détection des erreurs et des insights de code améliorés. Les améliorations clés incluent une autocomplétion plus intelligente, une prise en charge des fonctions lambda améliorée, des suggestions de paramètres, des informations contextuelles affichées lors du survol, un meilleur rendu des docstrings, et la mise en évidence des erreurs. Avec Pylance, l’écriture de code Python et PySpark devient plus rapide, plus précise et plus efficace.

Extraits de code

Les notebooks Fabric fournissent des extraits de code qui vous aident à écrire facilement des modèles de code couramment utilisés, par exemple :

  • Lecture de données sous forme de DataFrame Apache Spark
  • Dessin de graphiques avec Matplotlib

Les extraits de code apparaissent dans Touches de raccourci d’IntelliSense style IDE en combinaison avec d’autres suggestions. Le contenu des extraits de code s’aligne sur le langage des cellules de code. Vous pouvez voir les extraits de code disponibles en tapant Extrait de code. Vous pouvez également taper n’importe quel mot clé pour voir une liste d’extraits de code pertinents. Par exemple, si vous tapez lire, vous pouvez voir la liste des extraits de code pour lire les données à partir de différentes sources de données.

GIF animé d'extraits de code.

Glisser-déplacer pour insérer des extraits de code

Utilisez le glisser-déposer pour lire facilement les données depuis l’explorateur de Lakehouse. Plusieurs types de fichier sont pris en charge ici. Vous pouvez utiliser des fichiers texte, des tableaux, des images, etc. Vous pouvez déposer les éléments dans une cellule existante ou dans une nouvelle cellule. Le notebook génère l’extrait de code en conséquence pour afficher un aperçu des données.

GIF animé de glisser-déposer pour insérer des extraits.

Glisser-déplacer pour insérer des images

Utilisez le glisser-déposer pour insérer facilement des images de votre navigateur ou de votre ordinateur local dans une cellule Markdown.

GIF animé de glisser-déposer pour insérer des images.

Mettre en forme une cellule de texte avec des boutons de barre d’outils

Pour effectuer des actions Markdown courantes, utilisez les boutons de mise en forme dans la barre d’outils des cellules de texte.

Capture d'écran de la barre d'outils de formatage de texte.

Annuler ou rétablir les opérations sur les cellules

Sélectionnez Annuler ou Restaurer, ou appuyez sur Z ou Maj + Z pour révoquer les dernières opérations de cellule. Vous pouvez annuler ou rétablir jusqu'à 10 des dernières opérations de cellule effectuées.

Capture d'écran montrant les options du menu Annuler et Rétablir.

Opérations d’annulation de cellule prises en charge :

  • Insérer ou supprimer une cellule. Vous pouvez révoquer les opérations supprimées en sélectionnant Annuler (le contenu du texte est conservé avec la cellule).
  • Réorganiser la cellule.
  • Basculer le paramètre.
  • Effectuer une conversion entre une cellule de code et une cellule Markdown.

Remarque

Les opérations de texte dans les cellules et les opérations de commentaires des cellules de code ne peuvent pas être annulées. Vous pouvez annuler ou rétablir jusqu'à 10 des dernières opérations de cellule effectuées.

Déplacer une cellule

Vous pouvez faire glisser la partie vide d'une cellule et la déposer à l'emplacement souhaité.

Vous pouvez également déplacer la cellule sélectionnée à l’aide de Déplacer vers le haut et Déplacer vers le bas dans le ruban.

Capture d'écran montrant les options de déplacement d'une cellule.

Supprimer une cellule

Pour supprimer une cellule, sélectionnez le bouton Supprimer à droite de la cellule.

Vous pouvez également utiliser des touches de raccourci en mode de commande. Appuyez sur Maj + D pour supprimer la cellule active.

Réduire une entrée de cellule

Sélectionnez les points de suspension Plus de commandes (…) dans la barre d’outils de la cellule et Masquer l’entrée pour réduire l’entrée de la cellule actuelle. Pour la développer à nouveau, sélectionnez Afficher l’entrée quand la cellule est réduite.

Réduire une sortie de cellule

Sélectionnez les points de suspension Plus de commandes (…) dans la barre d’outils de la cellule et Masquer la sortie pour réduire la sortie de la cellule actuelle. Pour la développer à nouveau, sélectionnez Afficher la sortie quand la sortie de cellule est réduite.

Sécurité de la sortie de cellule

En utilisant les rôles d’accès aux données de OneLake (aperçu), les utilisateurs peuvent configurer l’accès à seulement certains dossiers dans un lakehouse lors des requêtes dans les notebooks. Les utilisateurs sans accès à un dossier ou à une table voient une erreur non autorisée lors de l’exécution de la requête.

Important

La sécurité s’applique uniquement pendant l’exécution de la requête et toutes les cellules de notebook contenant des résultats de requête peuvent être consultées par les utilisateurs qui ne sont pas autorisés à exécuter des requêtes directement sur les données.

Verrouiller ou figer une cellule

Les opérations de verrouillage et de blocage des cellules vous permettent de définir les cellules en lecture seule ou d’arrêter l’exécution des cellules de code de manière individuelle.

GIF animé du verrouillage ou du gel d'une cellule.

Fusionner et fractionner les cellules

Vous pouvez utiliser Fusionner avec la cellule précédente ou Fusionner avec la cellule suivante pour fusionner les cellules associées facilement.

La sélection de Fractionner la cellule vous permet de répartir des instructions non pertinentes sur plusieurs cellules. L’opération divise le code en fonction de la position de ligne de votre curseur.

Capture d’écran de l’opération de fusion et de division des cellules.

Contenu de Notebook

La sélection de Structure ou Table des matières présente le premier en-tête Markdown d’une cellule Markdown dans une fenêtre latérale pour une navigation rapide. Vous pouvez redimensionner et réduire la barre latérale Structure pour qu’elle s’adapte au mieux à l’écran. Sélectionnez le bouton Contenu de la barre de commandes du notebook pour ouvrir ou masquer la barre latérale.

Capture d'écran montrant où sélectionner l'option Contenu.

Repli Markdown

L’option de pliage Markdown vous permet de masquer des cellules sous une cellule Markdown qui contient un titre. La cellule Markdown et ses cellules masquées sont traitées de la même façon qu’un ensemble de cellules contiguës multi-sélectionnées lors de l’exécution d’opérations de cellule.

GIF animé du pliage Markdown.

Rechercher et remplacer

L’option Rechercher et remplacer peut vous aider à faire correspondre et localiser les mots clés ou l’expression dans le contenu de votre notebook. Vous pouvez également remplacer facilement la chaîne cible par une nouvelle chaîne.

Capture d'écran montrant le volet de recherche et de remplacement.

Complétion de code en ligne Copilot (aperçu)

La saisie semi-automatique de code intégré Copilot est une fonctionnalité alimentée par l’IA qui vous permet d’écrire du code Python plus rapidement et plus efficacement dans les Fabric Notebooks. Cette fonctionnalité fournit des suggestions de code intelligentes et contextuelles au fur et à mesure que vous tapez du code. Elle réduit les tâches répétitives, réduit les erreurs de syntaxe et accélère le développement en intégrant en toute transparence votre flux de travail de notebook.

Principaux avantages

  • Achèvements pilotés par l’IA : Génère des suggestions basées sur le contexte de votre notebook à l’aide d’un modèle entraîné sur des millions de lignes de code.
  • Améliore la productivité : Aide à écrire des fonctions complexes, réduit le codage répétitif et accélère l’exploration des bibliothèques inconnues.
  • Réduit les erreurs : Minimise les fautes de frappe et les erreurs de syntaxe grâce à des suggestions automatiques intelligentes et contextuelles.
  • Configuration minimale : Intégré aux notebooks Fabric, ne nécessite aucune installation. Vous pouvez simplement l’activer et commencer à coder.

Fonctionnement

Activez les suggestions de code en ligne avec le bouton bascule en bas de votre bloc-notes. Lorsque vous tapez, les suggestions s’affichent en texte gris clair, appuyez sur Tab pour accepter ou modifier. Les suggestions sont basées sur les cellules de cahier précédentes.

Capture d’écran montrant comment activer les complétions de code de Copilot.

Capture d’écran montrant la suggestion automatique de code avec la complétion de code Copilot.

Remarque

L’activation de la saisie semi-automatique du code inline Copilot consomme des unités de capacité supplémentaires.

Limitations actuelles

  • Copilot Inline Code Completion prend actuellement en charge le langage Python et utilise le contexte des cellules précédentes et des schémas Lakehouse.
  • Les suggestions prennent en compte les données des schémas Lakehouse.
  • Seul un sous-ensemble d’éléments de schéma est utilisé lorsqu’il existe de nombreuses tables ou colonnes.
  • Les tables créées dynamiquement (via Spark) ne sont pas reconnues en temps réel.

Exécuter des notebooks

Vous pouvez exécuter les cellules de code dans votre bloc-notes individuellement ou toutes en même temps. L’état et la progression de chaque cellule sont représentés dans le notebook.

Exécuter une cellule

Il existe plusieurs façons d’exécuter le code figurant dans une cellule.

  • Pointez sur la cellule à exécuter, puis sélectionnez le bouton Exécuter la cellule ou appuyez sur Ctrl + Entrée.

  • Utilisez les touches de raccourci en mode de commande. Appuyez sur Maj + Entrée pour exécuter la cellule active et sélectionner la cellule suivante. Appuyez sur Alt + Entrée pour exécuter la cellule active et insérer une nouvelle cellule.

Exécuter toutes les cellules

Sélectionnez le bouton Tout exécuter pour exécuter toutes les cellules du notebook actuel dans l’ordre.

Exécuter toutes les cellules au-dessus ou en dessous

Développez la liste déroulante de Tout exécuter, puis sélectionnez Exécuter les cellules ci-dessus pour exécuter dans l’ordre toutes les cellules au-dessus de la cellule actuelle. Sélectionnez Exécuter les cellules en dessous pour exécuter la cellule actuelle et toutes les cellules suivantes dans l'ordre.

Capture d'écran montrant les options du menu Exécuter tout.

Annuler toutes les cellules en cours d’exécution

Sélectionnez Tout annuler pour annuler les cellules en cours d’exécution ou les cellules de la file d’attente.

Arrêtez la session

Arrêter la session annule les cellules en cours d’exécution et en attente et arrête la session active. Vous pouvez redémarrer une toute nouvelle session en sélectionnant à nouveau l’option Exécuter.

Capture d'écran montrant où sélectionner Annuler toutes les exécutions et arrêter une session.

Référence d’exécution

Référence d’exécution d’un notebook

En plus de l’API d’exécution de référence notebookutils, vous pouvez également utiliser la commande magic %run <notebook name> pour référencer un autre notebook dans le contexte du notebook actuel. Toutes les variables définies dans le notebook de référence sont disponibles dans le notebook actuel. La commande magic %run prend en charge les appels imbriqués, mais pas les appels récursifs. Vous recevez une exception si la profondeur de l’instruction est supérieure à cinq.

Exemple : %run Notebook1 { "parameterInt": 1, "parameterFloat": 2.5, "parameterBool": true, "parameterString": "abc" }.

La référence de notebook fonctionne en mode interactif et en pipeline.

Remarque

  • La commande %run prend actuellement uniquement en charge les notebook de référence dans le même espace de travail que le notebook actuel.
  • La commande %run prend actuellement uniquement en charge quatre types de valeur de paramètre maximum : int, float, bool et string. L’opération de remplacement des variables n’est pas prise en charge.
  • La commande %run ne prend pas en charge les références imbriquées dont la profondeur est supérieure à cinq.

Référence d’exécution d’un script

La commande %run vous permet également d'exécuter des fichiers Python ou SQL stockés dans les ressources intégrées du notebook, afin de pouvoir exécuter facilement vos fichiers de code source dans le notebook.

%run [-b/--builtin -c/--current] [script_file.py/.sql] [variables ...]

Pour les options :

  • -b/-builtin: cette option indique que la commande recherche et exécute le fichier de script spécifié à partir des ressources intégrées du notebook.
  • -c/--current : cette option garantit que la commande utilise toujours les ressources intégrées du notebook actuel, même si le notebook actuel est référencé par d'autres notebooks.

Exemples :

  • Pour exécuter script_file.py à partir des ressources intégrées : %run -b script_file.py

  • Pour exécuter script_file.sql à partir des ressources intégrées : %run -b script_file.sql

  • Pour exécuter script_file.py à partir des ressources intégrées avec des variables spécifiques : %run -b script_file.py { "parameterInt": 1, "parameterFloat": 2.5, "parameterBool": true, "parameterString": "abc" }

Remarque

Si la commande ne contient pas -b/--builtin, elle tente de rechercher et d’exécuter l’élément de notebook dans le même espace de travail plutôt que les ressources intégrées.

Voici un exemple d'utilisation pour un cas de test imbriqué :

  • Supposons que nous avons deux cahiers.
    • Notebook1 : contient script_file1.py dans ses ressources intégrées
    • Notebook2 : contient script_file2.py dans ses ressources intégrées
  • Utilisons Notebook1 comme un carnet racine avec le contenu : %run Notebook2.
  • Ensuite, dans le Notebook2, l'instruction d'utilisation est la suivante :
    • Pour exécuter script_file1.py dans Bloc-Notes1(le Bloc-Notes racine), le code pourrait être : %run -b script_file1.py
    • Pour exécuter script_file2.py dans Notebook2(notebook actuel), le code est : %run -b -c script_file2.py

Explorateur de variables

Les notebooks Fabric fournissent un explorateur de variables intégré qui affiche la liste des noms, des types, des longueurs et des valeurs des variables dans la session Spark actuelle pour les cellules PySpark (Python). D'autres variables apparaissent automatiquement à mesure qu'elles seront définies dans les cellules de code. Un clic sur chaque en-tête de colonne permet de trier les variables de la table.

Pour ouvrir et masquer l’explorateur de variables, sélectionnez Variables sous Afficher dans le ruban du notebook.

Capture d'écran montrant où ouvrir les variables.

Remarque

L’explorateur de variables prend uniquement en charge Python.

Indicateur d’état de cellule

Un état d’exécution de cellule pas à pas est affiché sous la cellule pour vous aider à voir la progression en cours. Une fois l’exécution de la cellule terminée, un récapitulatif de l’exécution avec la durée totale et l’heure de fin s’affiche et reste disponible pour une utilisation ultérieure.

Capture d'écran montrant un exemple de détails sur l'état d'exécution d'une cellule.

Indicateur d’état de session

Configuration du délai d’expiration de session

Dans le coin inférieur gauche, vous pouvez sélectionner l’état de la session pour obtenir plus d’informations sur la session active :

Capture d’écran montrant les informations de session.

Dans la fenêtre contextuelle, il existe une option permettant de réinitialiser le délai d’expiration sur x minutes ou heures.

Capture d’écran montrant le délai d’expiration de session.

Prenez votre choix dans la durée pendant laquelle vous souhaitez une session ininterrompue et appuyez sur appliquer. Le délai d’expiration de la session se réinitialise avec la nouvelle valeur et vous êtes prêt à continuer !

Vous pouvez également définir le délai d’expiration comme décrit dans :

Restez connecté : Pendant la connexion, si vous voyez la boîte de dialogue Rester connecté , sélectionnez Oui pour désactiver le délai d’expiration de la session inactive pour votre session active.

Important

Ne cochez pas la case Ne pas afficher cette nouvelle fois, car cela verrouillera définitivement vos paramètres de connexion. Notez que cette option peut ne pas apparaître si votre administrateur client a désactivé le paramètre Keep Me Sign In (KMSI).

Demander une modification de stratégie : Si vous avez besoin d’une durée de session plus longue, demandez à votre administrateur client d’étendre la stratégie de durée d’expiration de session inactive. Pour ce faire, accédez aux Paramètres de l'organisation > Sécurité et confidentialité > Délai d'expiration de session inactivité dans le Centre d'administration M365.

Remarque

La sélection de KMSI et/ou l’extension du délai d’expiration du délai d’inactivité de la session étendront le risque d’accès à un ordinateur déverrouillé.

Comment ABT et le délai d'expiration d'inactivité de session affectent-ils les exécutions prolongées des notebooks Fabric ?

Si votre locataire utilise le délai d’expiration basé sur l’activité (ABT), les travaux interactifs de longue durée dans les notebooks Fabric peuvent être affectés par la stratégie de délai d’expiration de session inactive de Microsoft 365. Cette fonctionnalité de sécurité est conçue pour déconnecter les utilisateurs sur des appareils inactifs, non gérés, même si un travail de notebook est toujours en cours d’exécution. Bien que l’activité dans d’autres applications Microsoft 365 puisse maintenir la session active, les appareils inactifs sont déconnectés par conception.

Pourquoi les utilisateurs se déconnectent-ils même lorsqu’un travail de bloc-notes est toujours en cours d’exécution ?

L'expiration des sessions inactives priorise la sécurité en mettant fin aux sessions sur les appareils inactifs pour empêcher l’accès non autorisé. Même lorsqu’une exécution de notebook est en cours, la session se termine si l’appareil n’affiche aucune activité. La conservation des sessions ouvertes sur les appareils inactifs compromettrait la sécurité, c’est pourquoi le comportement actuel est appliqué.

Indicateur de travail Apache Spark intégré

Le notebook Fabric est basé sur Apache Spark. Les cellules de code sont exécutées sur le cluster Apache Spark à distance. Un indicateur de progression du travail Spark est fourni avec une barre de progression en temps réel qui s’affiche pour vous aider à comprendre l’état d’exécution du travail. Le nombre de tâches par travail ou phase vous aide à identifier le niveau parallèle de votre travail Spark. Vous pouvez également accéder plus en profondeur à l'interface utilisateur Spark d'un travail (ou d'une étape) spécifique en sélectionnant le lien sur le nom du travail (ou de l'étape).

Vous pouvez également trouver le journal en temps réel au niveau de la cellule à côté de l'indicateur de progression, et Diagnostics peut vous fournir des suggestions utiles pour affiner et déboguer le code.

Capture d'écran des détails de l'avancement des travaux Spark.

Dans Autres actions, vous pouvez facilement accéder à la page des détails de l’application Spark et à la page d’interface utilisateur web Spark .

Capture d'écran des détails d'autres actions.

Rédaction des secrets

Pour éviter que les informations d’identification ne soient accidentellement divulguées pendant l’exécution de notebooks, les notebooks Fabric prennent en charge la rédaction de secret pour remplacer les valeurs de secret affichées dans la sortie de cellule par [REDACTED]. La rédaction de secret s’applique à Python, Scala et R.

Capture d'écran de la rédaction secrète.

Commandes magiques dans un carnet

Commandes magiques intégrées

Vous pouvez utiliser les commandes magic familières d'Ipython dans les carnets Fabric. Consultez la liste suivante des commandes magic actuellement disponibles.

Remarque

Seules les commandes magiques suivantes sont prises en charge dans le pipeline Fabric : %%pyspark, %%spark, %%csharp, %%sql, %%configure.

Commandes magic de ligne disponibles : %lsmagic, %time, %timeit, %history, %run, %load, %alias, %alias_magic, %autoawait, %autocall, %automagic, %bookmark, %cd, %colors, %dhist, %dirs, %doctest_mode, %killbgscripts, %load_ext, %logoff, %logon, %logstart, %logstate, %logstop, %magic, %matplotlib, %page, %pastebin, %pdef, %pfile, %pinfo, %pinfo2, %popd, %pprint, %precision, %prun, %psearch, %psource, %pushd, %pwd, %pycat, %quickref, %rehashx, %reload_ext, %reset, %reset_selective, %sx, %system, %tb, %unalias, %unload_ext, %who, %who_ls, %whos, %xdel, %xmode.

Le notebook Fabric prend également en charge les commandes de gestion de bibliothèque améliorées %pip et %conda. Pour plus d’informations sur l’utilisation, consultez Gérer les bibliothèques Apache Spark dans Microsoft Fabric.

Commandes magic de cellule disponibles : %%time, %%timeit, %%capture, %%writefile, %%sql, %%pyspark, %%spark, %%csharp, %%configure, %%html, %%bash, %%markdown, %%perl, %%script, %%sh.

Commandes magic personnalisées

Vous pouvez également créer des commandes magic personnalisées pour répondre à vos besoins spécifiques. Voici un exemple :

  1. Créez un notebook nommé « MyLakehouseModule ».

    Capture d'écran de la définition d'un magic personnalisé.

  2. Dans un autre notebook, référencez « MyLakehouseModule » et ses commandes magic. Ce processus vous permet d’organiser facilement votre projet avec des notebooks qui utilisent différents langages.

    Capture d'écran de l'utilisation de la magie personnalisée.

Widgets IPython

Les widgets IPython sont des objets Python avec événements qui ont une représentation dans le navigateur. Vous pouvez utiliser les widgets IPython comme contrôles de code de base (par exemple, curseur ou zone de texte) dans votre notebook, tout comme le notebook Jupyter. Actuellement, il fonctionne uniquement dans un contexte Python.

Pour utiliser les widgets IPython

  1. Commencez par importer le module ipywidgets pour utiliser le framework de widgets Jupyter.

    import ipywidgets as widgets

  2. Utilisez la fonction display de niveau supérieur pour afficher un widget, ou laissez une expression de type widget sur la dernière ligne de la cellule de code.

    slider = widgets.IntSlider()
display(slider)

  3. Exécutez la cellule. Le widget s’affiche dans la zone de sortie.

    slider = widgets.IntSlider()
display(slider)

    Capture d'écran du widget affiché dans la zone de sortie.

  4. Utilisez plusieurs appels display() pour afficher plusieurs fois la même instance de widget. Ils restent synchronisés les uns avec les autres.

    slider = widgets.IntSlider()
display(slider)
display(slider)

    Capture d'écran montrant plusieurs fois un même widget.

  5. Pour afficher deux widgets indépendamment l’un de l’autre, créez deux instances de widget :

    slider1 = widgets.IntSlider()
slider2 = widgets.IntSlider()
display(slider1)
display(slider2)

    Capture d'écran montrant plusieurs instances de widgets.

Widgets pris en charge

Type de widgets Widgets
Widgets numériques IntSlider, FloatSlider, FloatLogSlider, IntRangeSlider, FloatRangeSlider, IntProgress, FloatProgress, BoundedIntText, BoundedFloatText, IntText, FloatText
Widgets booléens Bouton bascule, Case à cocher, Valide
Widgets de sélection Liste déroulante, Boutons radio, Sélectionner, Curseur de sélection, Curseur de plage de sélection, Boutons bascule, Sélection multiple
Widgets de chaîne de caractères Texte, Zone de texte, Liste déroulante, Mot de passe, Étiquette, HTML, Mathématiques HTML, Image, Bouton
Widgets de lecture (animation) Sélecteur de date, Sélecteur de couleur, Contrôleur
Widgets de conteneur ou disposition Box, HBox, VBox, GridBox, Accordéon, Tabs, Stacked

Limitations connues

  • Les widgets suivants ne sont pas encore pris en charge. Les solutions de contournement suivantes sont disponibles :

    Fonctionnalités Solution de contournement
    Widget de sortie Vous pouvez utiliser la fonction imprimer() pour écrire du texte dans stdout.
    widgets.jslink() Vous pouvez utiliser la fonction widgets.link() pour lier deux widgets similaires.
    Widget FileUpload Pas encore pris en charge.

  • La fonction display globale Fabric ne prend pas en charge l’affichage de plusieurs widgets dans un appel (par exemple, display(a, b)). Ce comportement diffère de celui de la fonction display IPython.

  • Si vous fermez un notebook qui contient un widget IPython, vous ne pouvez pas le voir ni interagir avec lui tant que vous ne réexécutez pas la cellule correspondante.

  • La fonction interact (ipywidgets.interact) n’est pas prise en charge.

Intégrer un notebook

Désigner une cellule de paramètres

Pour paramétrer votre notebook, sélectionnez les points de suspension (…) pour accéder aux commandes Plus au niveau de la barre d’outils de la cellule. Sélectionnez ensuite Activer/désactiver la cellule Paramètres pour désigner la cellule comme cellule de paramètre.

Capture d'écran montrant où sélectionner l'option Activer/désactiver la cellule paramètre.

La cellule de paramètre est utile pour intégrer un notebook dans un pipeline. L'activité du pipeline recherche la cellule des paramètres et la considère comme la valeur par défaut des paramètres transmis au moment de l'exécution. Le moteur d’exécution a une nouvelle cellule sous la cellule des paramètres avec des paramètres d’entrée en vue de remplacer les valeurs par défaut.

Attribuer des valeurs de paramètres à partir d’un pipeline

Une fois que vous avez créé un notebook avec des paramètres, vous pouvez l’exécuter à partir d’un pipeline avec l’activité de notebook Fabric. Après avoir ajouté l’activité à votre canevas de pipeline, vous pouvez définir les valeurs des paramètres sous la section Paramètres de base de l’onglet Paramètres.

Capture d’écran montrant où attribuer des valeurs de paramètres à partir d’un pipeline.

Quand vous attribuez des valeurs de paramètre, vous pouvez utiliser le langage d’expression du pipeline ou des fonctions et des variables.

Commande de configuration magique de session Spark

Vous pouvez personnaliser votre session Spark avec la commande magic %%configure. Le notebook Fabric prend en charge les vCores personnalisés, la mémoire du pilote et de l’exécuteur, les propriétés Apache Spark, les points de montage, le pool et le lakehouse par défaut de la session de notebook. Ils peuvent être utilisés dans les activités de notebook interactives et de pipeline. Nous vous recommandons d’exécuter la commande %%configure au début de votre notebook, sinon vous devez redémarrer la session Spark pour que les paramètres prennent effet.

%%configure
{
    // You can get a list of valid parameters to config the session from https://github.com/cloudera/livy#request-body.
    "driverMemory": "28g", // Recommended values: ["28g", "56g", "112g", "224g", "400g"]
    "driverCores": 4, // Recommended values: [4, 8, 16, 32, 64]
    "executorMemory": "28g",
    "executorCores": 4,
    "jars": ["abfs[s]: //<file_system>@<account_name>.dfs.core.windows.net/<path>/myjar.jar", "wasb[s]: //<containername>@<accountname>.blob.core.windows.net/<path>/myjar1.jar"],
    "conf":
    {
        // Example of customized property, you can specify count of lines that Spark SQL returns by configuring "livy.rsc.sql.num-rows".
        "livy.rsc.sql.num-rows": "3000",
        "spark.log.level": "ALL"
    },
    "defaultLakehouse": {  // This overwrites the default lakehouse for current session
        "name": "<lakehouse-name>",
        "id": "<(optional) lakehouse-id>",
        "workspaceId": "<(optional) workspace-id-that-contains-the-lakehouse>" // Add workspace ID if it's from another workspace
    },
    "mountPoints": [
        {
            "mountPoint": "/myMountPoint",
            "source": "abfs[s]://<file_system>@<account_name>.dfs.core.windows.net/<path>"
        },
        {
            "mountPoint": "/myMountPoint1",
            "source": "abfs[s]://<file_system>@<account_name>.dfs.core.windows.net/<path1>"
        },
    ],
    "environment": {
        "id": "<environment-id>",
        "name": "<environment-name>"
    },
    "sessionTimeoutInSeconds": 1200,
    "useStarterPool": false,  // Set to true to force using starter pool
    "useWorkspacePool": "<workspace-pool-name>"
}

Remarque

  • Nous vous recommandons de définir la même valeur pour « DriverMemory » et « ExecutorMemory » dans %%configure. Les valeurs « driverCores » et « executorCores » doivent également être identiques.
  • Le « defaultLakehouse » remplace votre lakehouse épinglé dans l’explorateur de lakehouse, mais cela fonctionne uniquement dans votre session de notebook actuelle.
  • Vous pouvez utiliser %%configure dans les pipelines Fabric, mais s’il n’est pas défini dans la première cellule de code, l’exécution du pipeline échoue en raison de ne pas pouvoir redémarrer la session.
  • Quand la commande %%configure est utilisée dans notebookutils.notebook.run, elle est ignorée, mais le notebook continue de l’exécuter si elle est utilisée dans %run.
  • Les propriétés de configuration Spark standard doivent être utilisées dans le corps « conf ». Fabric ne prend pas en charge la référence de premier niveau pour les propriétés de configuration Spark.
  • Certaines propriétés Spark spéciales, y compris « spark.driver.cores », « spark.executor.cores », « spark.driver.memory », « spark.executor.memory » et « spark.executor.instances » ne sont pas prises en compte dans le corps « conf ».

Vous pouvez également utiliser %%configure la commande magic pour injecter dynamiquement des valeurs de configuration de la bibliothèque de variables dans votre notebook.

%%configure
{
  "defaultLakehouse": {
    "name": {
      "variableName": "$(/**/myVL/LHname)" 
    },
    "id": {
      "variableName": "$(/**/myVL/LHid)"
    },
    "workspaceId": "<(optional) workspace-id-that-contains-the-lakehouse>"
  }
}

Dans cet exemple :

  • myVL est le nom de votre bibliothèque de variables.
  • LHname et LHid sont des clés variables définies dans la bibliothèque.
  • Ces valeurs sont résolues au moment de l’exécution en fonction de l’environnement actif (par exemple, Dev, Test, Prod).

Cela vous permet de changer de configuration comme lakehouse par défaut sans modifier votre code de notebook.

Configuration de session paramétrisée à partir d’un pipeline

La configuration de session paramétrisée vous permet de remplacer la valeur dans la commande magic %%configure par les paramètres d’activité de notebook de l’exécution de pipeline. Lorsque vous préparez la cellule de code %%configure, vous pouvez remplacer les valeurs par défaut (également configurables, 4 et « 2000 » dans l’exemple ci-dessous) par un objet comme celui-ci :

{
      "parameterName": "paramterNameInPipelineNotebookActivity",
      "defaultValue": "defaultValueIfNoParamterFromPipelineNotebookActivity"
} 

%%configure  

{ 
    "driverCores": 
    { 
        "parameterName": "driverCoresFromNotebookActivity", 
        "defaultValue": 4 
    }, 
    "conf": 
    { 
        "livy.rsc.sql.num-rows": 
        { 
            "parameterName": "rows", 
            "defaultValue": "2000" 
        } 
    } 
}

Un notebook utilise la valeur par défaut si vous l’exécutez en mode interactif directement ou si l’activité de notebook de pipeline ne donne aucun paramètre correspondant à « activityParameterName ».

Pendant une exécution de pipeline, vous pouvez configurer les paramètres d’activité du notebook de pipeline de la façon suivante :

Capture d’écran montrant où configurer une session parameterisée.

Si vous voulez changer la configuration de session, le nom des paramètres d’activité de notebook du pipeline doit être identique à parameterName dans le notebook. Dans cet exemple d’exécution d’un pipeline, les driverCores dans %%configure sont remplacés par 8, et les livy.rsc.sql.num-rows sont remplacés par 4000.

Remarque

  • Si l'exécution du pipeline échoue parce que vous avez utilisé la commande magique %%configure, recherchez plus d'informations sur l'erreur en exécutant la cellule magique %%configure dans le mode interactif du notebook.
  • Les exécutions planifiées de notebook ne prennent pas en charge la configuration de session paramétrisée.

Journalisation de Python dans un notebook

Vous pouvez trouver les journaux Python et définir différents niveaux et formats de journaux comme dans l'exemple de code montré ici :

import logging

# Customize the logging format for all loggers
FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
formatter = logging.Formatter(fmt=FORMAT)
for handler in logging.getLogger().handlers:
    handler.setFormatter(formatter)

# Customize log level for all loggers
logging.getLogger().setLevel(logging.INFO)

# Customize the log level for a specific logger
customizedLogger = logging.getLogger('customized')
customizedLogger.setLevel(logging.WARNING)

# logger that use the default global log level
defaultLogger = logging.getLogger('default')
defaultLogger.debug("default debug message")
defaultLogger.info("default info message")
defaultLogger.warning("default warning message")
defaultLogger.error("default error message")
defaultLogger.critical("default critical message")

# logger that use the customized log level
customizedLogger.debug("customized debug message")
customizedLogger.info("customized info message")
customizedLogger.warning("customized warning message")
customizedLogger.error("customized error message")
customizedLogger.critical("customized critical message")

Afficher l’historique des commandes d’entrée

Le notebook Fabric prend en charge la commande magique %history pour imprimer l’historique des commandes d’entrée qui se sont exécutées dans la session active. Par rapport à la commande standard Jupyter Ipython, la commande %history fonctionne dans un contexte multilingue au sein du notebook.

%history [-n] [range [range ...]]

Pour les options :

  • -n : Imprimer le numéro d'exécution.

Où l'intervalle peut être :

  • N : imprimer le code de la cellule exécutée Nth.
  • M-N : imprimer le code de Mth à la cellule exécutée Nth.

Exemple :

  • Imprimer l’historique des entrées de la première à la deuxième cellule exécutée : %history -n 1-2

Touches de raccourci

Tout comme les notebooks Jupyter, les notebooks Fabric disposent d’une interface utilisateur modale. Le clavier effectue des actions différentes selon le mode dans lequel se trouve la cellule du bloc-notes. Les notebooks Fabric prennent en charge les deux modes suivants pour une cellule de code donnée : le mode de commande et le mode d’édition.

  • Une cellule est en mode commande quand elle n’y a pas de curseur de texte vous invitant à taper quelque chose. Quand une cellule est en mode de commande, vous pouvez modifier le bloc-notes entier, mais pas taper dans des cellules individuelles. Entrez en mode de commande en appuyant sur Échap ou en utilisant la souris pour sélectionner en dehors de la zone de l’éditeur d’une cellule.

    Capture d'écran d'une cellule en mode commande.

  • Le mode d'édition peut être indiqué par un curseur de texte qui vous invite à taper dans la zone d'édition. Quand une cellule est en mode d’édition, vous pouvez saisir dans la cellule. Entrez en mode d’édition en appuyant sur Entrée ou en utilisant la souris pour sélectionner la zone de l’éditeur d’une cellule.

    Capture d'écran d'une cellule en mode d’édition.

Touches de raccourci en mode de commande

Action Raccourcis de notebook
Exécuter la cellule active et sélectionner ce qui se trouve en dessous Maj + Entrée
Exécuter la cellule active et insérer en dessous Alt + Entrée
Exécuter la cellule active CTRL+ Enter
Sélectionner la cellule au-dessus Haut
Sélectionner la cellule en dessous Bas
Sélectionner la cellule précédente K
Sélectionner la cellule suivante J
Insérer une cellule au-dessus Un
Insérer une cellule en dessous B
Supprimer les cellules sélectionnées Maj + D
Basculer en mode d’édition Entrez

Touches de raccourci en mode d’édition

Les raccourcis clavier suivants vous permettent de naviguer et d’exécuter du code facilement dans les notebooks Fabric en mode d’édition.

Action Raccourcis de notebook
Monter le curseur Haut
Déplacer le curseur vers le bas Bas
Annuler Ctrl + Z
Rétablir CTRL + Y
Commentaire ou annulation des commentaires Ctrl + /
Mettre en commentaire : Ctrl + K + C
Supprimer les marques de commentaire : Ctrl+K+U
Supprimer le mot précédent Ctrl + Retour arrière
Supprimer le mot suivant Ctrl + Suppr
Atteindre le début de la cellule Ctrl + Début
Atteindre la fin de la cellule Ctrl + Fin
Atteindre le mot à gauche CTRL + Gauche
Atteindre le mot à droite Ctrl + Droite
Sélectionner tout Ctrl + A
Mettre en retrait Ctrl + ] (raccourci clavier)
Retrait négatif Ctrl + [
Passer en mode de commande Échap

Pour rechercher toutes les touches de raccourci, sélectionnez Afficher dans le ruban du notebook, puis sélectionnez Combinaisons de touches.

Contenu connexe