DevOps et observabilité
CI/CD Microsoft Fabric avec fabric-cicd : de Git vers DEV, QA et PROD
Un guide de production pour déployer des éléments Microsoft Fabric depuis Git avec la bibliothèque fabric-cicd de Microsoft : structure du dépôt, authentification, paramétrage, CI et CD.
Dans cet article
Connecter un espace de travail Fabric à Git vous donne un historique des versions. Cela ne vous donne pas un processus de mise en production. Tôt ou tard, il faut répondre à des questions plus difficiles : comment un notebook relu arrive-t-il en QA, comment la copie de production finit-elle par pointer vers le Lakehouse de production, et comment savoir que ce qui tourne en PROD correspond bien à main ?
La bibliothèque open source fabric-cicd de Microsoft répond à ces questions avec une petite API Python. Ce guide montre comment je l’utilise en production : où elle se situe, comment structurer le dépôt, comment s’authentifier, comment remplacer les identifiants propres à chaque environnement, et ce que la CI et le CD doivent prendre en charge. Les exemples utilisent Azure DevOps, mais les mêmes principes s’appliquent à GitHub Actions.
Pourquoi fabric-cicd existe
Trois activités sont souvent confondues :
- Le développement dans Fabric. Les ingénieurs construisent des notebooks, des pipelines et des modèles dans un espace de travail, généralement depuis l’interface Fabric.
- Le contrôle de source. L’intégration Git de Fabric sérialise chaque élément en fichiers (les métadonnées
.platformet des fichiers de définition commenotebook-content.pyoupipeline-content.json) et les synchronise avec une branche. - Le déploiement. Les mêmes définitions sont appliquées à un autre espace de travail, avec remplacement des valeurs propres à l’environnement, de façon reproductible et auditable.
L’intégration Git couvre les deux premières. C’est un mécanisme de synchronisation entre un espace de travail et une branche, pas un mécanisme de promotion entre environnements. fabric-cicd couvre la troisième : elle lit les définitions d’éléments dans un répertoire du dépôt et appelle les API REST Fabric pour créer ou mettre à jour ces éléments dans un espace de travail cible.
Cette distinction a une conséquence opérationnelle. Les espaces de travail qui reçoivent des déploiements ne sont pas des espaces de développement. Si des personnes modifient directement des éléments en QA ou en PROD, le déploiement suivant écrase la modification ou, pire, la modification survit dans certains éléments et pas dans d’autres. Un espace de travail déployé ne doit changer que lorsque le pipeline s’exécute.
Le modèle de déploiement
- 1Branche de fonctionnalitéCréée depuis main
- 2Espace de développementConnecté par Git Sync
- 3Pull requestRevue et validation CI
- 4mainBranche protégée
- 5Déploiement fabric-cicdPipeline de mise en production
- 6QAEspace déployé
- 7PRODMême commit, approuvé
Ce flux suit le Git flow et la philosophie de déploiement que Microsoft documente pour fabric-cicd :
- Les branches de fonctionnalité sont connectées à des espaces de développement par Git Sync. C’est là que l’on travaille dans l’interface Fabric.
- Les espaces de travail déployés ne sont pas connectés à Git. Ils ne sont mis à jour que par des déploiements scriptés.
- Chaque exécution est un déploiement complet. fabric-cicd n’examine pas l’historique des commits et ne calcule pas de différences. Chaque élément dont le type figure dans
item_type_in_scopeest créé ou mis à jour à chaque exécution, si bien que la cible converge vers l’état du dépôt quoi qu’il se soit passé auparavant. - Les éléments orphelins sont supprimés explicitement.
unpublish_all_orphan_items()supprime les éléments des types concernés qui existent dans l’espace de travail mais plus dans le dépôt.
Le déploiement sélectif et la détection des changements à partir de Git existent sous forme de fonctionnalités expérimentales, mais Microsoft ne recommande pas le déploiement sélectif par défaut, car des dépendances non résolues peuvent casser une mise en production. Déployer tout ce qui est dans le périmètre est plus lent que déployer un seul notebook modifié, mais c’est prévisible, et c’est précisément l’objectif.
Le scénario de référence de Microsoft utilise une branche déployée par environnement : les fonctionnalités sont fusionnées dans la branche par défaut puis reportées vers les branches supérieures par cherry-pick. Une variante courante, celle de ce guide, conserve un seul main protégé et promeut le même commit en QA, STAGING et PROD, avec des approbations entre les étapes. Les deux respectent la règle essentielle : les espaces déployés ne sont jamais modifiés à la main ni synchronisés avec Git.
Installation
fabric-cicd est un package Python :
pip install fabric-cicd
Dans un pipeline, épinglez la version que vous avez validée, par exemple dans un fichier requirements-deploy.txt, afin qu’une nouvelle version ne modifie jamais le comportement du déploiement à votre insu. Lisez le journal des modifications avant une mise à niveau : les exigences d’authentification, par exemple, ont changé d’une version à l’autre.
Si vous préférez la ligne de commande à un script Python, la Fabric CLI exécute fabric-cicd en arrière-plan avec fab deploy, à partir d’un fichier config.yml et du même parameter.yml :
pip install ms-fabric-cli
fab deploy --config config.yml --target_env prod
Structure du dépôt
fabric-cicd déploie depuis un répertoire qui contient les éléments validés par le contrôle de source Fabric, plus un fichier parameter.yml facultatif à sa racine. Gardez tout le reste, comme les scripts de déploiement et les définitions de pipeline, en dehors de ce répertoire.
.
├── .deploy/
│ └── deploy_workspace.py
├── pipelines/
│ ├── fabric-release.yml
│ └── templates/
│ └── deploy-fabric.yml
├── requirements-deploy.txt
└── workspace/
├── Ingest Orders.Notebook/
│ ├── .platform
│ └── notebook-content.py
├── Load Orders.DataPipeline/
├── Sales.Lakehouse/
├── Sales Warehouse.Warehouse/
├── Platform Settings.VariableLibrary/
├── Sales.SemanticModel/
├── Sales Overview.Report/
└── parameter.yml
Chaque élément se trouve dans un dossier nommé <nom de l’élément>.<type d’élément>. Les sous-dossiers d’espace de travail sont pris en charge : vous pouvez donc regrouper les éléments comme dans Fabric. La connexion Git de l’espace de développement doit pointer vers ce dossier workspace/, afin que ce que les ingénieurs valident depuis l’interface soit exactement ce que le pipeline déploie.
Décidez tôt quels types d’éléments relèvent du pipeline. Les projets sur lesquels je travaille déploient Notebook, DataPipeline, Lakehouse, Warehouse, VariableLibrary, SemanticModel et Report. Chaque type ajouté au périmètre devient un élément que le pipeline crée, met à jour et peut supprimer : ajoutez les types de façon délibérée.
Authentification
Les versions actuelles de fabric-cicd exigent des identifiants explicites. Le paramètre token_credential doit être un objet qui implémente TokenCredential d’azure-identity. Deux comportements anciens ne sont plus pris en charge : le repli sur DefaultAzureCredential et l’authentification implicite dans un notebook Fabric sans token_credential. Les scripts qui s’appuyaient sur l’un ou l’autre échouent désormais à l’authentification, et c’est voulu.
| Où s’exécute le déploiement | Identifiants | Remarques |
|---|---|---|
| Développement local | AzureCliCredential ou AzurePowerShellCredential |
Utilise l’identité de az login ou Connect-AzAccount |
| Azure DevOps avec une connexion de service | AzureCliCredential ou AzurePowerShellCredential |
Exécutez le script dans une tâche AzureCLI@2 ou AzurePowerShell@5 ; la plateforme gère la connexion |
| Pipeline avec le secret d’un principal de service | ClientSecretCredential |
Lisez le secret depuis une variable sécurisée ou Key Vault, jamais depuis le dépôt |
| Agent auto-hébergé sur Azure | ManagedIdentityCredential |
Aucun secret à renouveler ; l’identité managée de l’agent doit avoir accès à l’espace de travail |
| Notebook Fabric | Des identifiants explicites | Les exemples d’authentification montrent un modèle avec la session du notebook et un autre avec un principal de service |
Dans Azure DevOps, je préfère AzureCliCredential dans une tâche AzureCLI@2 avec une connexion de service. La plateforme de pipeline gère le secret ou l’identifiant fédéré, et le script Python ne contient qu’une ligne de logique d’authentification.
Quelle que soit l’identité qui exécute le déploiement, elle doit pouvoir créer et mettre à jour des éléments dans chaque espace de travail cible. Elle doit aussi avoir accès aux connexions utilisées par les pipelines de données : si elle ne voit pas une connexion, le déploiement du pipeline échoue.
Le script de déploiement
Le script est volontairement court. Tout ce qui varie selon l’environnement vient du pipeline : l’espace de travail cible et le nom de l’environnement.
"""Deploy the Fabric items in ./workspace to one target workspace."""
import os
import sys
from pathlib import Path
from azure.identity import AzureCliCredential
from fabric_cicd import (
FabricWorkspace,
change_log_level,
publish_all_items,
unpublish_all_orphan_items,
)
# Stream output immediately in pipeline logs
sys.stdout.reconfigure(line_buffering=True, write_through=True)
sys.stderr.reconfigure(line_buffering=True, write_through=True)
if os.getenv("SYSTEM_DEBUG", "false").lower() == "true":
change_log_level("DEBUG")
repo_root = Path(__file__).resolve().parent.parent
target_workspace = FabricWorkspace(
workspace_id=os.environ["TARGET_WORKSPACE_ID"],
environment=os.environ["TARGET_ENVIRONMENT"], # DEV, QA, STAGING or PROD
repository_directory=str(repo_root / "workspace"),
item_type_in_scope=[
"Lakehouse",
"Warehouse",
"VariableLibrary",
"Notebook",
"DataPipeline",
"SemanticModel",
"Report",
],
token_credential=AzureCliCredential(),
)
publish_all_items(target_workspace)
unpublish_all_orphan_items(target_workspace)
La valeur environment sélectionne les remplacements de parameter.yml et le jeu de valeurs actif de chaque Variable Library. Elle doit correspondre exactement aux clés utilisées dans ces fichiers. fabric-cicd publie les types d’éléments dans son propre ordre de dépendance (les Variable Libraries et les Warehouses avant les éléments qui y font référence) : l’ordre de item_type_in_scope n’a donc pas d’importance.
DEV, QA, STAGING et PROD
| Espace de travail | Comment il change | Qui le modifie |
|---|---|---|
| Espaces de fonctionnalité ou de développement | Git Sync avec une branche de fonctionnalité | Les ingénieurs, depuis l’interface Fabric |
| DEV (intégration) | Déploiement par pipeline depuis main |
Personne directement |
| QA | Déploiement par pipeline, après DEV | Personne directement |
| STAGING | Déploiement par pipeline, avec approbation | Personne directement |
| PROD | Déploiement par pipeline du même commit, avec approbation | Personne directement |
Toutes les équipes n’ont pas besoin de quatre environnements déployés. Ce qui compte, c’est la frontière : les seuls espaces que l’on modifie sont les espaces de développement synchronisés avec Git, et tous les autres environnements sont des cibles de déploiement.
Donnez à chaque environnement son propre espace de travail, ses propres données de Lakehouse et de Warehouse, et ses propres connexions. Déployer des définitions d’éléments ne déplace pas de données ; un notebook de PROD qui pointe encore vers le Lakehouse de DEV est l’erreur de déploiement la plus courante, et la plus dangereuse.
Paramétrer les valeurs propres à chaque environnement
Les définitions validées depuis l’espace de développement contiennent des identifiants de développement : le Lakehouse par défaut de chaque notebook, l’espace de travail qui le possède, les ID de point de terminaison d’analytique SQL dans les pipelines et les modèles sémantiques, les ID de connexion. parameter.yml indique à fabric-cicd comment les remplacer pour chaque environnement. Le fichier se trouve à la racine du répertoire du dépôt et il est validé au début de chaque déploiement ; un fichier invalide arrête l’exécution.
find_replace:
# Default Lakehouse attached to notebooks
- find_value: "your-dev-lakehouse-id"
replace_value:
_ALL_: "$items.Lakehouse.Sales.$id"
item_type: "Notebook"
# Workspace that owns the default Lakehouse
- find_value: "your-dev-workspace-id"
replace_value:
_ALL_: "$workspace.$id"
item_type: "Notebook"
# Lakehouse SQL analytics endpoint used by pipelines and the semantic model
- find_value: "your-dev-lakehouse-sql-endpoint-id"
replace_value:
_ALL_: "$items.Lakehouse.Sales.$sqlendpointid"
item_type: ["DataPipeline", "SemanticModel"]
key_value_replace:
# Run schedules only in production
- find_key: $.schedules[?(@.jobType=="Execute")].enabled
replace_value:
DEV: false
QA: false
STAGING: false
PROD: true
file_path: "**/.schedules"
semantic_model_binding:
default:
connection_id:
DEV: "your-dev-connection-id"
QA: "your-qa-connection-id"
STAGING: "your-staging-connection-id"
PROD: "your-prod-connection-id"
Quelques détails rendent ce fichier fiable :
- Préférez les valeurs dynamiques aux GUID codés en dur.
$workspace.$idse résout en l’espace de travail cible et$items.Lakehouse.Sales.$iden le Lakehouse nomméSalesdans cet espace.$sqlendpointidrenvoie l’ID du point de terminaison d’analytique SQL d’un Lakehouse. Vous n’avez plus à maintenir une table de GUID de production, et la même entrée fonctionne pour tous les environnements. _ALL_applique une valeur à n’importe quel environnement. Ce doit être la seule clé de cereplace_value.- Filtrez chaque remplacement.
item_type,item_nameetfile_pathlimitent les endroits où une valeur est remplacée. Un remplacement de GUID non filtré touche tous les fichiers du dépôt. - N’utilisez les expressions régulières qu’avec du contexte.
find_replaceaccepteis_regex, par exemple pour capturer le GUID qui suit# META "default_lakehouse":. Ne ciblez jamais le seul format d’un GUID, sinon vous remplacerez des identifiants sans rapport. - Nommez les environnements de façon cohérente.
QAetqasont des clés différentes. Si l’environnement passé àFabricWorkspaceest absent d’une entrée, ce remplacement est ignoré.
Certaines limites méritent d’être connues avant de compter sur le paramétrage. find_replace ne s’applique pas aux éléments Lakehouse ou Warehouse. Les connexions ne sont pas sous contrôle de source : elles doivent exister dans chaque environnement avant le déploiement. Dès qu’une variable dynamique est utilisée, fabric-cicd résout les points de terminaison SQL de chaque Lakehouse et Warehouse de l’espace cible ; si l’un d’eux est encore en cours de provisionnement, le déploiement échoue avant toute publication.
Les Variable Libraries complètent parameter.yml. Nommez chaque jeu de valeurs d’après un environnement (DEV, QA, PROD), et fabric-cicd active le jeu qui correspond à la valeur environment. Gardez dans les Variable Libraries la configuration d’exécution lue par les notebooks et les pipelines, et dans parameter.yml le câblage entre éléments, comme les Lakehouses par défaut et les ID de points de terminaison.
Ce qui se passe dans la CI
La CI s’exécute sur chaque pull request vers main. Elle ne déploie jamais en QA ni en PROD. Son rôle est d’empêcher une définition cassée d’atteindre la branche à partir de laquelle les versions sont produites :
mainprotégé : les changements n’arrivent que par pull request, avec au moins un relecteur et une build réussie.- Contrôles de structure : chaque dossier sous
workspace/suit le format<nom>.<type>et contient un fichier.platform. - Validation des paramètres :
parameter.ymlest lisible, chaque clé d’environnement est orthographiée de façon cohérente et chaque variable dynamique fait référence à un élément présent dans le dépôt. fabric-cicd fournit dans son dépôt un scriptdebug_parameterization.pyqui valide le fichier sans déployer. - Identifiants qui fuient : faites échouer la build si un ID connu d’espace de travail ou de Lakehouse de développement apparaît dans un fichier que
parameter.ymlne couvre pas. - Secrets : aucun secret client, aucune clé ni chaîne de connexion dans les définitions d’éléments.
Certaines équipes déploient aussi chaque commit fusionné dans l’espace DEV partagé, comme première étape du CD. C’est un test d’intégration utile : il prouve que le commit se déploie avant que quiconque ne demande à la QA de l’examiner.
Ce qui se passe dans le CD
Le pipeline de mise en production déploie un même commit dans chaque environnement, l’un après l’autre. Dans Azure DevOps, un modèle d’étape réutilisable garde tous les environnements identiques, à leurs entrées près :
# pipelines/templates/deploy-fabric.yml
parameters:
- name: environment
type: string
- name: serviceConnection
type: string
- name: workspaceId
type: string
- name: dependsOn
type: object
default: []
stages:
- stage: Deploy_${{ parameters.environment }}
dependsOn: ${{ parameters.dependsOn }}
jobs:
- deployment: Deploy
environment: fabric-${{ parameters.environment }}
pool:
vmImage: ubuntu-latest
strategy:
runOnce:
deploy:
steps:
- checkout: self
- task: UsePythonVersion@0
inputs:
versionSpec: '3.12'
- script: pip install -r requirements-deploy.txt
displayName: Install fabric-cicd
- task: AzureCLI@2
displayName: Deploy to ${{ parameters.environment }}
inputs:
azureSubscription: ${{ parameters.serviceConnection }}
scriptType: bash
scriptLocation: inlineScript
inlineScript: python -u .deploy/deploy_workspace.py
env:
TARGET_ENVIRONMENT: ${{ parameters.environment }}
TARGET_WORKSPACE_ID: ${{ parameters.workspaceId }}
# pipelines/fabric-release.yml
trigger:
branches:
include:
- main
pr: none
stages:
- template: templates/deploy-fabric.yml
parameters:
environment: QA
serviceConnection: your-qa-service-connection
workspaceId: your-qa-workspace-id
- template: templates/deploy-fabric.yml
parameters:
environment: STAGING
serviceConnection: your-staging-service-connection
workspaceId: your-staging-workspace-id
dependsOn: [Deploy_QA]
- template: templates/deploy-fabric.yml
parameters:
environment: PROD
serviceConnection: your-prod-service-connection
workspaceId: your-prod-workspace-id
dependsOn: [Deploy_STAGING]
Les approbations et les contrôles sont définis sur les environnements Azure DevOps (fabric-STAGING, fabric-PROD) et non dans le YAML : personne ne peut donc les supprimer dans une pull request. Les ID d’espaces de travail ne sont pas des secrets, mais les placer dans un groupe de variables par environnement évite de modifier le pipeline lorsqu’un espace de travail est recréé. Une connexion de service distincte par environnement garantit que l’identité de QA ne peut pas toucher à la PROD.
Comme le modèle est partagé, une correction du processus de déploiement atteint tous les environnements et tous les dépôts Fabric qui l’utilisent. C’est la principale raison de centraliser les modèles de pipeline plutôt que de les copier d’un projet à l’autre.
Éviter les dérives des espaces de travail
La dérive est l’écart entre ce que dit le dépôt et ce que contient un espace de travail. Un déploiement complet en élimine l’essentiel à chaque exécution, mais seulement pour ce qui est dans le périmètre :
- Restreignez les autorisations. Dans les espaces déployés, les personnes ont un rôle Viewer ou limité ; l’identité de déploiement est le seul principal qui modifie les éléments.
- Faites passer les correctifs par Git. Un correctif appliqué directement en PROD est écrasé par la mise en production suivante. Faites-le dans une branche, fusionnez-le et déployez-le.
- Décidez ce que signifie la dépublication.
unpublish_all_orphan_items()supprime les éléments du périmètre qui ne sont pas dans le dépôt. La dépublication des Lakehouses et des Warehouses est désactivée par défaut pour protéger les données. Utilisezitem_name_exclude_regexpour les éléments volontairement gérés hors de Git. - Sachez ce qui n’est pas déployé. Les connexions, les ressources des notebooks, les données et les schémas des Lakehouses (sauf si un raccourci les définit) et le DDL des Warehouses restent hors de fabric-cicd. Seule l’enveloppe de l’élément Warehouse est déployée ; déployez son schéma avec un DACPAC, dbt ou un autre outil de base de données.
- Ne synchronisez jamais un espace déployé avec Git. Cela crée un second moyen, concurrent, de modifier les mêmes éléments.
Que valider après un déploiement
Un pipeline au vert signifie que les API ont accepté les définitions. Cela ne prouve pas que la plateforme fonctionne. Après chaque déploiement, vérifiez :
- Chaque élément a réussi. Un échec doit arrêter l’étape, et non laisser un espace partiellement mis à jour qui semble terminé.
- Les notebooks pointent vers le Lakehouse cible. Ouvrez-en un ou interrogez ses métadonnées ; le Lakehouse par défaut et son espace de travail doivent appartenir à l’environnement cible, jamais à DEV.
- Les pipelines appellent les éléments cibles et utilisent les connexions de l’environnement.
- Les modèles sémantiques sont liés et s’actualisent. Lancez une actualisation et vérifiez qu’elle lit le point de terminaison SQL cible.
- Les rapports s’ouvrent sur le modèle sémantique déployé.
- Les Variable Libraries ont le jeu de valeurs actif attendu.
- Les planifications ne sont activées que là où elles doivent s’exécuter.
- Une exécution de contrôle réussit : une petite exécution de pipeline ou de notebook qui parcourt le chemin principal et apparaît dans votre supervision des pipelines et notebooks.
- La mise en production est consignée : ID du commit, environnement, approbateur et résultat.
La checklist de déploiement CI/CD Fabric imprimable (en anglais) reprend ces étapes avant, pendant et après une mise en production.
Erreurs et modes de défaillance fréquents
- Compter sur l’authentification par défaut. Sans
token_credentialexplicite, les versions actuelles de fabric-cicd échouent. Les anciens scripts qui n’en passaient pas cessent de fonctionner après une mise à niveau. - Des noms d’environnement différents.
Proddans le pipeline etPRODdansparameter.ymlsignifient qu’aucun remplacement n’a lieu, et les éléments de production gardent les ID de développement. - Un
find_valuequi ne correspond pas. Les fichiers validés contiennent un autre GUID que celui deparameter.yml, souvent parce que quelqu’un a rattaché un Lakehouse dans l’espace de développement. - Des remplacements non filtrés qui modifient des ID dans des fichiers qu’ils n’auraient jamais dû toucher.
- Un point de terminaison SQL encore en provisionnement dans l’espace cible, qui fait échouer tout le déploiement lorsque des variables dynamiques sont utilisées.
- Un accès manquant aux connexions pour l’identité de déploiement, qui fait échouer les pipelines de données.
- Renommer ou supprimer un jeu de valeurs d’une Variable Library après le premier déploiement, ce qui fait échouer les déploiements suivants jusqu’à une correction dans l’interface Fabric.
- Recréer trop vite un élément portant le même nom. Fabric réserve les noms des éléments supprimés pendant quelques minutes.
- La limitation de débit. Les grands espaces de travail peuvent recevoir
429 Too Many Requests; réessayez plus tard ou découpez les très gros déploiements. - Des déploiements sélectifs par défaut, qui laissent des dépendances non résolues.
- S’attendre à ce que les données ou les schémas de Warehouse suivent les éléments.
En cas d’échec, activez la journalisation de débogage avec change_log_level() (ou définissez SYSTEM_DEBUG dans Azure DevOps avec le script ci-dessus) et lisez le guide de dépannage. Définissez FABRIC_CICD_FILE_LOGGING_ENABLED si vous voulez le fichier détaillé fabric_cicd.error.log.
Recommandations pratiques
- Faites de Git la seule porte d’entrée d’un espace déployé. Les espaces de développement sont synchronisés avec Git ; tous les autres sont des cibles de déploiement.
- Gardez un script de déploiement court et générique. L’environnement, l’ID d’espace de travail et les identifiants viennent du pipeline.
- Utilisez les variables dynamiques (
$workspace.$id,$items.<type>.<name>.$id,$sqlendpointid) plutôt que de maintenir des GUID de production. - Filtrez chaque remplacement par type d’élément, nom d’élément ou chemin de fichier.
- Promouvez un même commit en QA, STAGING et PROD, avec des approbations sur les environnements du pipeline.
- Utilisez une identité de déploiement et une connexion de service distinctes par environnement.
- Épinglez la version de fabric-cicd et mettez-la à niveau délibérément, après avoir lu le journal des modifications.
- Déployez les schémas de Warehouse et créez les connexions avec leurs propres outils, avant les éléments qui en dépendent.
- Validez la plateforme après chaque mise en production, pas seulement le résultat du pipeline.
Ainsi utilisé, fabric-cicd rend les déploiements Fabric ennuyeux : le même commit, le même script et les mêmes contrôles dans chaque environnement. Pour la conception d’ensemble de la plateforme qui accueille ces environnements, consultez Concevoir une architecture Microsoft Fabric évolutive.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Continuer à apprendre
- Aide-mémoireSuperviser les pipelines et notebooks FabricSupervisez les pipelines et notebooks Microsoft Fabric avec le Monitoring hub, Workspace Monitoring, la supervision Spark, KQL, les alertes et la télémétrie de capacité afin de rendre observables les échecs et les régressions de performances.Ouvrir l’aide-mémoire
- ArticleIntégration Git dans Microsoft Fabric : un workflow de développement pratiqueComment 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.Lire l’article
Que devrais-je créer ensuite ?
Je développe Javi Builds autour des problèmes concrets rencontrés par les data engineers. Dites-moi quel sujet vous aimeriez voir ensuite.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.