DevOps et observabilité

Intégration Git dans Microsoft Fabric : un workflow de développement pratique

Comment l’intégration Git de Fabric fonctionne vraiment au quotidien : espace de travail et branche, commit et mise à jour, branch out, pull requests, conflits, dérive et permissions.

Par JaviPublié 11 min de lectureIntermédiaire

L’intégration Git de Fabric est la fonctionnalité qui permet à une équipe de ne plus traiter un espace de travail comme l’unique copie de son travail. Les notebooks, pipelines, modèles sémantiques, rapports et les définitions de Lakehouse et de Warehouse deviennent des fichiers dans un dépôt Git, avec un historique, des branches et des pull requests.

Elle est aussi facile à mal utiliser. Des équipes connectent un espace de travail partagé à main, laissent cinq personnes le modifier, et découvrent que l’intégration Git ne leur a apporté ni isolation, ni revue, ni déploiement. Elle leur a apporté l’historique des versions d’un désordre partagé.

Ce guide porte sur le workflow de développement : comment une modification passe de l’espace de travail d’un ingénieur à un commit relu sur main. La promotion de ce commit vers la QA et la production est un autre travail, traité dans CI/CD Microsoft Fabric avec fabric-cicd : de Git vers DEV, QA et PROD. Garder ces deux responsabilités séparées est l’idée la plus importante de cet article.

Ce que fait l’intégration Git de Fabric

L’intégration Git fonctionne au niveau de l’espace de travail. Un espace de travail est connecté à un dépôt Git, une branche et un dossier de ce dépôt. Une fois la connexion établie :

  • Chaque élément pris en charge est sérialisé dans un dossier de fichiers : un fichier de métadonnées .platform plus des fichiers de définition comme notebook-content.py, pipeline-content.json, ou des fichiers TMDL pour un modèle sémantique.
  • Les dossiers de l’espace de travail sont reproduits sous forme de dossiers dans Git, jusqu’à dix niveaux de profondeur.
  • Un panneau Source control (contrôle de code source) indique quels éléments ont changé dans l’espace de travail (à commiter) et lesquels ont changé dans la branche (à mettre à jour).
  • Vous pouvez commiter les modifications de l’espace de travail vers la branche et mettre à jour l’espace de travail à partir de la branche.

Les fournisseurs pris en charge sont Azure DevOps, GitHub et GitHub Enterprise, tous dans leurs versions cloud. La plupart des éléments courants de data engineering sont pris en charge, notamment les Lakehouses, notebooks, définitions de jobs Spark, Environments, pipelines, Dataflow Gen2, Warehouses, modèles sémantiques et rapports, même si certains types d’éléments sont encore en préversion. Vérifiez la liste à jour avant de dépendre d’un élément particulier.

Ce qu’elle ne fait pas

L’intégration Git, c’est du contrôle de source et de la synchronisation. Ce n’est pas :

  • Un outil de déploiement. Elle ne promeut pas un commit vers la QA ou la production, ne remplace pas les ID propres à chaque environnement et ne décide pas quel espace de travail reçoit quelle version. C’est le rôle des pipelines de déploiement ou de fabric-cicd.
  • Une sauvegarde des données. Elle versionne les définitions des éléments, pas les données. Les tables du Lakehouse, les fichiers de la zone Files et les vues Spark ne sont pas suivis ; mettre à jour un espace de travail depuis Git ne les écrase pas et ne les restaure pas. Un Warehouse est commité sous forme de projet de base de données (son schéma), pas de ses lignes.
  • Un processus de revue à elle seule. Commiter depuis l’espace de travail directement sur main est possible, et cela contourne entièrement la revue, sauf si des stratégies de branche l’empêchent.
  • De l’isolation. Un espace de travail, c’est un seul runtime. Toutes les personnes qui y travaillent partagent les mêmes éléments, quelle que soit la branche à laquelle il est connecté.

Une fois cette frontière claire, le reste du workflow en découle.

Espace de travail et branche : la seule règle qui compte

Un espace de travail ne peut être connecté qu’à une seule branche à la fois, et chaque modification faite dans l’espace de travail affecte tous ceux qui l’utilisent. Les recommandations de Microsoft sont donc que les développeurs travaillent dans des espaces de travail séparés, chacun connecté à sa propre branche, plutôt que de partager un même espace à plusieurs.

Cela donne une règle simple :

Une modification active, une branche, un espace de travail.

La règle produit ce flux :

  1. 1Feature branch
  2. 2Espace de travail Fabric de développementConnecté à la feature branch
  3. 3Modifier et tester les éléments
  4. 4Commiter depuis le panneau Source control
  5. 5Pull request vers main
  6. 6Revue et merge
  7. 7Processus de déploiementQA, puis production
Workflow par feature branch

L’étape de déploiement à la fin ne fait délibérément pas partie de l’intégration Git. Les espaces de travail déployés ne sont pas connectés à Git ; ils sont mis à jour par le pipeline de mise en production à partir d’un commit relu.

Configurer un espace de travail de développement

Un administrateur de l’espace de travail connecte celui-ci à un dépôt, une branche et un dossier depuis Workspace settings → Git integration. Faites pointer le dossier vers le répertoire que lit votre outillage de déploiement (par exemple un dossier workspace/), afin que ce que les développeurs commitent soit exactement ce que le pipeline déploie.

Lors de la première connexion, Fabric synchronise les deux côtés :

  • Si l’espace de travail ou la branche est vide, le contenu est copié depuis le côté non vide.
  • Si les deux ont du contenu, c’est vous qui choisissez le sens. Commiter l’espace de travail écrase le contenu de la branche ; mettre à jour l’espace de travail depuis Git écrase le contenu de l’espace de travail.

Lisez ce choix attentivement. Une branche Git peut toujours être restaurée à un commit antérieur ; un espace de travail écrasé par une mise à jour ne le peut pas. En cas de doute, commitez d’abord l’espace de travail vers une nouvelle branche.

La connexion Git est propre à chaque utilisateur. Chaque personne qui travaille dans un espace de travail connecté s’authentifie auprès du fournisseur Git avec son propre compte. Ne partagez pas un personal access token au sein d’une équipe.

Une branche par développeur ou un espace de développement partagé

Il existe deux configurations de développement courantes.

Une branche par développeur (recommandé). Chaque ingénieur utilise l’action Branch out (créer une branche) dans le panneau Source control. Fabric crée une nouvelle branche Git à partir du dernier commit de l’espace de travail source et, soit crée un nouvel espace de travail connecté à cette branche, soit bascule un espace existant. Le nouvel espace de travail est lié à sa source en tant que branch workspace, ce qui permet d’y revenir facilement. Le branchement sélectif vous permet de n’apporter que certains éléments dans le nouvel espace de travail, à condition de sélectionner aussi leurs dépendances.

Avantages : une vraie isolation, des pull requests petites et ciblées, et personne n’écrase le notebook de quelqu’un d’autre. Coût : davantage d’espaces de travail, et chacun a besoin de ses propres données pour les tests.

Espace de développement partagé. Un seul espace de travail connecté à une branche dev partagée, utilisé par une petite équipe. C’est plus simple, et cela fonctionne quand deux ou trois personnes se coordonnent étroitement. Cela se dégrade à mesure que l’équipe grandit : la modification à moitié terminée d’une personne devient le problème de tout le monde, les commits mélangent des travaux sans rapport, et les revues perdent leur sens.

Un compromis pratique consiste à avoir un espace de travail d’intégration partagé qui ne reçoit que des modifications fusionnées, plus des branch workspaces individuels pour l’édition. Personne ne modifie directement l’espace d’intégration ; il est mis à jour depuis main et sert à vérifier que le travail fusionné s’assemble correctement.

Synchronisation : commit et mise à jour

Deux opérations font circuler les modifications entre l’espace de travail et la branche.

Commit (espace de travail → Git). La section Changes liste les éléments modifiés dans l’espace de travail. Vous pouvez sélectionner les éléments à commiter et ajouter un message. La vue de comparaison permet aussi de commiter des fichiers précis au sein d’un élément, pour les éléments pris en charge. Si la branche contient de nouveaux commits que vous n’avez pas récupérés, le commit est désactivé tant que vous n’avez pas fait de mise à jour. Fabric ne vous laisse pas commiter par-dessus un état de la branche que vous n’avez pas vu.

Mise à jour (espace de travail ← Git). La section Updates liste les éléments modifiés dans la branche. Contrairement au commit, la mise à jour applique toujours la branche entière jusqu’au dernier commit ; vous ne pouvez pas choisir des éléments individuels. Si le même élément a changé des deux côtés, la mise à jour est désactivée jusqu’à la résolution du conflit.

Cette asymétrie façonne la routine quotidienne :

  1. Commencez la journée par une mise à jour pour que votre espace de travail corresponde à la branche.
  2. Faites vos modifications, testez-les dans l’espace de travail, puis commitez des ensembles d’éléments petits et cohérents.
  3. Refaites une mise à jour avant de commiter si quelqu’un d’autre a poussé sur votre branche.

Comme les notebooks sont stockés sous forme de fichiers source, les messages de commit et les diffs sont lisibles dans les pull requests. Gardez des notebooks ciblés, et passez les valeurs d’exécution par des paramètres plutôt que de modifier le code pour chaque environnement ; Paramètres des notebooks Microsoft Fabric couvre ce modèle.

Pull requests et main protégé

Fabric n’exécute pas les pull requests ; c’est votre fournisseur Git qui le fait. C’est un avantage : la revue, les stratégies de branche, les approbateurs obligatoires et la validation de build se trouvent là où se trouve déjà votre processus d’ingénierie.

Configuration recommandée :

  • Protégez main. Exigez des pull requests, au moins un relecteur et une build de validation réussie. Les commits directs depuis un espace de travail vers main doivent être rejetés par une stratégie de branche.
  • Validez en CI. Vérifiez que les dossiers d’éléments sont bien formés, que le fichier de paramètres de déploiement est valide, et qu’aucun ID de développement ne s’est glissé dans des fichiers que le déploiement ne réécrit pas.
  • Relisez les définitions d’éléments, pas seulement le code. Une modification du JSON d’un pipeline, un nouveau raccourci de Lakehouse ou une relation de modèle sémantique se relisent tout autant qu’une cellule Python.
  • Fusionnez, puis déployez. Après la fusion, le pipeline de mise en production déploie main vers l’environnement suivant. Personne ne copie d’éléments à la main entre espaces de travail.

Après une fusion, les développeurs mettent à jour leurs espaces de travail (ou créent un nouveau branch workspace à partir de main) pour la modification suivante.

Scénarios de conflit

Un conflit survient lorsque le même élément a changé dans l’espace de travail et dans la branche depuis la dernière synchronisation. L’élément affiche un statut Conflict, le commit est désactivé, et la mise à jour propose Resolve conflicts.

Vous avez quatre façons d’en sortir :

  1. Choisir une version par élément dans l’interface. Accept incoming changes écrase la version de l’espace de travail avec celle de la branche. Keep current content conserve la version de l’espace de travail, qui doit ensuite être commitée. La vue de comparaison affiche les deux versions côte à côte avant que vous décidiez.
  2. Revenir au dernier état synchronisé. Undo ramène les éléments en conflit de l’espace de travail à leur dernière version synchronisée ; côté Git, vous pouvez annuler des commits avec un revert.
  3. Résoudre dans Git. Utilisez Checkout new branch pour créer une branche à partir du dernier commit synchronisé, commitez-y les modifications de votre espace de travail, fusionnez-la avec la branche d’origine dans votre fournisseur Git (en y résolvant le conflit), puis rebasculez l’espace de travail sur la branche d’origine.
  4. Mise à jour manuelle après un échec de mise à jour. Une mise à jour peut aussi échouer sans conflit direct, par exemple lorsqu’un élément dépendant a été renommé ou supprimé. Fabric indique quel élément a échoué pour que vous puissiez corriger et réessayer.

La plupart des conflits viennent de deux personnes qui modifient le même élément dans la même branche. Les branch workspaces par développeur les rendent rares ; quand ils surviennent, les résoudre dans Git avec une fusion classique est généralement l’option la plus claire.

Dérive de l’espace de travail

La dérive est l’écart entre ce que dit la branche et ce que contient l’espace de travail. Dans un espace de développement, une certaine dérive est normale : c’est votre travail non commité. Les problèmes commencent quand la dérive devient permanente :

  • Des modifications non commitées qui durent. Un travail qui reste des jours dans un espace de travail est invisible pour les relecteurs et perdu si l’espace de travail est écrasé. Commitez tôt dans une branche de fonctionnalité ; une branche ne coûte rien.
  • Des éléments que l’intégration ne suit pas. Les données, les tables et fichiers du Lakehouse, ainsi que les connexions, ne sont pas dans Git. Documentez la façon dont un nouveau branch workspace obtient les données dont il a besoin pour les tests, sinon chaque développeur inventera sa propre configuration.
  • Des espaces de travail déployés connectés à Git. Un espace de travail de QA ou de production connecté à une branche offre une deuxième manière de le modifier. Gardez les espaces déployés déconnectés et ne les mettez à jour que via le pipeline de mise en production.
  • Les liaisons au Lakehouse par défaut. Les définitions de notebooks portent leur Lakehouse par défaut dans leurs métadonnées. Fabric peut lier automatiquement les notebooks au Lakehouse correspondant dans un autre espace de travail, mais vérifiez la liaison après un branch out ; un notebook de branch workspace qui écrit toujours dans le Lakehouse de l’espace source est une forme discrète de dérive.

Permissions

Les permissions viennent de deux endroits, et les deux doivent autoriser une action :

Action Espace de travail Fabric Fournisseur Git
Connecter, déconnecter, modifier la connexion Admin Accès en lecture au dépôt
Commiter les modifications de l’espace de travail Contributor ou plus, avec accès en écriture à tous les éléments Accès en écriture, et la stratégie de branche doit autoriser un commit direct sur cette branche
Mettre à jour l’espace de travail depuis Git Contributor ou plus, avec accès en écriture à tous les éléments Accès en lecture
Changer de branche ou faire un checkout vers une nouvelle branche Admin, ou Member/Contributor si l’espace de travail le permet Lecture ; permission de création de branche pour une nouvelle branche
Faire un branch out vers un autre espace de travail Contributor ou plus Lecture et permission de création de branche

Les Viewers ne peuvent ni voir les informations Git ni effectuer d’actions Git. Les administrateurs du tenant doivent activer l’intégration Git, ainsi que les exports entre zones géographiques pour Azure DevOps lorsque l’espace de travail et le dépôt sont dans des régions différentes. Ce sont les stratégies de branche sur main qui empêchent réellement les commits directs : configurez-les donc dans le fournisseur Git ; Fabric les respecte.

Erreurs courantes

  • Plusieurs développeurs dans un seul espace de travail sur une seule branche, en attendant de Git qu’il les isole.
  • Commiter directement sur main depuis un espace de travail parce que les stratégies de branche n’ont jamais été configurées.
  • Traiter l’intégration Git comme un déploiement, en connectant les espaces de travail de QA et de production à des branches et en les « mettant à jour ».
  • Attendre de Git qu’il restaure les données. Il restaure les définitions ; les tables et les fichiers ne sont pas touchés.
  • Choisir « mettre à jour l’espace de travail » lors de la première connexion sans vérifier quel côté contient le travail le plus récent.
  • Des commits énormes qui mélangent des éléments sans rapport, ce qui rend la revue et la résolution des conflits pénibles. GitHub et Azure DevOps appliquent aussi des limites de taille de commit.
  • Partager un seul personal access token pour toute l’équipe au lieu de connexions par utilisateur.
  • Coder en dur des valeurs d’environnement dans les notebooks, si bien que chaque promotion exige une modification au lieu d’un paramètre.

Recommandation

Utilisez l’intégration Git pour ce pour quoi elle est conçue : versionner les définitions d’éléments et les faire circuler entre l’espace de travail d’un développeur et une branche. Donnez à chaque modification active sa propre branche et son propre branch workspace, protégez main avec des pull requests et de la validation, et considérez une fusion dans main comme la seule entrée du déploiement.

Passez ensuite le relais à un processus de déploiement qui connaît les environnements. L’intégration Git répond à « qu’est-ce qui a changé et qui l’a approuvé ». fabric-cicd répond à « qu’est-ce qui tourne en QA et en production ». Gardez ces réponses séparées et toutes deux restent fiables. Pour voir comment ces espaces de travail s’intègrent dans la plateforme globale, consultez Concevoir une architecture Microsoft Fabric évolutive.

Étiquettes

  • Microsoft Fabric
  • Git
  • DevOps
  • CI/CD