Publication automatisée pour l’intégration continue et le déploiement continu (CI/CD)

S'APPLIQUE À : Azure Data Factory Azure Synapse Analytics

Vue d’ensemble

L’intégration continue consiste à tester automatiquement chaque modification apportée à votre codebase. Dès que possible, la livraison continue fait suite au test effectué pendant l’intégration continue et envoie (push) les modifications à un système de mise en lots ou de production.

Dans Azure Data Factory, CI/CD signifie déplacer des pipelines Data Factory d’un environnement, comme le développement, le test et la production, vers un autre. Data Factory utilise des modèles Azure Resource Manager (modèles ARM) pour stocker la configuration de vos différentes entités Data Factory, telles que les pipelines, les jeux de données et les flux de données.

Deux méthodes sont recommandées pour promouvoir une fabrique de données dans un autre environnement :

• Déploiement automatisé grâce à l’intégration de Data Factory avec Azure Pipelines.
• Chargement manuel d’un modèle ARM à l’aide de l’intégration de l’expérience utilisateur Data Factory à Azure Resource Manager.

Pour plus d’informations, consultez Intégration et livraison continues dans Azure Data Factory.

Cet article se concentre sur les améliorations du déploiement continu et la fonctionnalité de publication automatisée pour CI/CD.

Améliorations du déploiement continu

La fonctionnalité de publication automatisée utilise les fonctionnalités Tout valider et Exporter un modèle ARM de l’expérience utilisateur de Data Factory, puis rend la logique consommable via un package npm accessible publiquement : @microsoft/azure-data-factory-utilities. Pour cette raison, vous pouvez déclencher ces actions par programmation au lieu d’accéder à l’interface utilisateur de Data Factory et de sélectionner un bouton manuellement. Cette capacité offre à vos pipelines CI/CD une expérience d’intégration continue plus fidèle.

Flux actuel de CI/CD

1. Chaque utilisateur apporte des modifications à ses branches privées.
2. Push vers le main n’est pas autorisé. Les utilisateurs doivent créer une pull request pour apporter des modifications.
3. Les utilisateurs doivent charger l’interface utilisateur de Data Factory et sélectionner Publier pour déployer les modifications apportées à Data Factory et générer les modèles ARM dans la branche de publication.
4. Le pipeline de mise en production DevOps est configuré pour créer une nouvelle version et déployer le modèle ARM chaque fois qu’une nouvelle modification est envoyée (push) à la branche de publication.

Étape manuelle

Dans le flux de CI/CD actuel, l’expérience utilisateur est l’intermédiaire permettant de créer le modèle ARM. Par conséquent, un utilisateur doit accéder à l’interface utilisateur de Data Factory et sélectionner manuellement Publier pour démarrer la génération du modèle ARM et le déposer dans la branche de publication.

Nouveau flux de CI/CD

1. Chaque utilisateur apporte des modifications à ses branches privées.
2. Push vers le main n’est pas autorisé. Les utilisateurs doivent créer une pull request pour apporter des modifications.
3. La compilation du pipeline Azure DevOps est déclenchée à chaque nouvelle validation vers le main. Cela valide les ressources et génère un modèle ARM comme artefact si la validation réussit.
4. Le pipeline de déploiement DevOps est configuré pour créer une nouvelle version et déployer le modèle ARM chaque fois qu’un nouveau build est disponible.

Qu’est ce qui a changé ?

• Vous avez maintenant un processus de compilation qui utilise un pipeline de compilation DevOps.
• Le pipeline de build utilise le package ADFUtilities (@microsoft/azure-data-factory-utilities) npm, qui valide toutes les ressources et génère les modèles ARM. Ces modèles peuvent être uniques et liés.
• Le pipeline de compilation valide les ressources Data Factory et génère le modèle ARM au lieu de l’interface utilisateur Data Factory (bouton Publier ).
• La définition de version DevOps consomme désormais ce nouveau pipeline de compilation au lieu de l’artefact Git.

Vue d’ensemble du package

Deux commandes sont actuellement disponibles dans le package :

• Exporter un modèle ARM
• Valider

Exporter un modèle ARM

Exécutez npm run build export <rootFolder> <factoryId> [outputFolder] pour exporter le modèle ARM en utilisant les ressources d’un dossier donné. Cette commande effectue également une vérification de validation avant de générer le modèle ARM. Voici un exemple qui utilise un groupe de ressources nommé testResourceGroup :

npm run build export C:\DataFactories\DevDataFactory /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/testResourceGroup/providers/Microsoft.DataFactory/factories/DevDataFactory ArmTemplateOutput

• RootFolder est un champ obligatoire qui indique où se trouvent les ressources Data Factory.
• FactoryId est un champ obligatoire qui représente l’ID de ressource Data Factory au format /subscriptions/<subId>/resourceGroups/<rgName>/providers/Microsoft.DataFactory/factories/<dfName>.
• OutputFolder est un paramètre facultatif qui spécifie le chemin d’accès relatif pour enregistrer le modèle ARM généré.

La possibilité d’arrêter/démarrer uniquement les déclencheurs mis à jour est désormais généralement disponible et est intégrée à la commande précédente.

Valider

Exécutez npm run build validate <rootFolder> <factoryId> pour valider toutes les ressources d’un dossier donné. Voici un exemple :

npm run build validate C:\DataFactories\DevDataFactory /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/testResourceGroup/providers/Microsoft.DataFactory/factories/DevDataFactory

• RootFolder est un champ obligatoire qui indique où se trouvent les ressources Data Factory.
• FactoryId est un champ obligatoire qui représente l’ID de ressource Data Factory au format /subscriptions/<subId>/resourceGroups/<rgName>/providers/Microsoft.DataFactory/factories/<dfName>.

Créer un pipeline Azure

Bien que les packages npm puissent être consommés de différentes manières, l’un des principaux avantages est d’être exploité via Azure Pipelines. À chaque fusion dans votre branche de collaboration, un pipeline peut être déclenché qui valide d’abord tout le code puis exporte le modèle ARM en un artefact de compilation qui peut être consommé par un pipeline de release. Ce qui diffère du processus actuel CI/CD, c’est que vous pointez votre pipeline de libération vers cet artefact plutôt que vers la branche existanteadf_publish.

Effectuez d’abord ces étapes :

1. Ouvrez un projet Azure DevOps et accédez à Pipelines. Sélectionnez Nouveau pipeline.

   

2. Sélectionnez le référentiel dans lequel vous souhaitez enregistrer le script YAML de votre pipeline. Sauvegardez-le dans un dossier de compilation dans le même dépôt que vos ressources Data Factory. Assurez-vous qu’il existe un fichier package.json dans le référentiel qui contient le nom du package, comme indiqué dans l’exemple suivant :

   {
       "scripts":{
           "build":"node node_modules/@microsoft/azure-data-factory-utilities/lib/index"
       },
       "dependencies":{
           "@microsoft/azure-data-factory-utilities":"^1.0.0"
       }
   } 
   

3. Sélectionnez Pipeline de démarrage. Si vous avez chargé ou fusionné le fichier YAML, comme indiqué dans l’exemple suivant, vous pouvez également pointer directement sur ce fichier et le modifier.

   

   # Sample YAML file to validate and export an ARM template into a build artifact
   # Requires a package.json file located in the target repository
   
   trigger:
   - main #collaboration branch
   
   pool:
     vmImage: 'ubuntu-latest'
   
   steps:
   
   # Installs Node and the npm packages saved in your package.json file in the build
   
   - task: UseNode@1
     inputs:
       version: '20.x'
     displayName: 'Install Node.js'
   
   - task: Npm@1
     inputs:
       command: 'install'
       workingDir: '$(Build.Repository.LocalPath)/<folder-of-the-package.json-file>' #replace with the package.json folder
       verbose: true
     displayName: 'Install npm package'
   
   # Validates all of the Data Factory resources in the repository. You'll get the same validation errors as when "Validate All" is selected.
   # Enter the appropriate subscription and name for the source factory. Either of the "Validate" or "Validate and Generate ARM template" options are required to perform validation. Running both is unnecessary.
   
   - task: Npm@1
     inputs:
       command: 'custom'
       workingDir: '$(Build.Repository.LocalPath)/<folder-of-the-package.json-file>' #replace with the package.json folder
       customCommand: 'run build validate $(Build.Repository.LocalPath)/<Root-folder-from-Git-configuration-settings-in-ADF> /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/<Your-ResourceGroup-Name>/providers/Microsoft.DataFactory/factories/<Your-Factory-Name>'
     displayName: 'Validate'
   
   # Validate and then generate the ARM template into the destination folder, which is the same as selecting "Publish" from the UX.
   # The ARM template generated isn't published to the live version of the factory. Deployment should be done by using a CI/CD pipeline. 
   
   - task: Npm@1
     inputs:
       command: 'custom'
       workingDir: '$(Build.Repository.LocalPath)/<folder-of-the-package.json-file>' #replace with the package.json folder
       customCommand: 'run build export $(Build.Repository.LocalPath)/<Root-folder-from-Git-configuration-settings-in-ADF> /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/<Your-ResourceGroup-Name>/providers/Microsoft.DataFactory/factories/<Your-Factory-Name> "ArmTemplate"'
   #For using preview that allows you to only stop/ start triggers that are modified, please comment out the above line and uncomment the below line. Make sure the package.json contains the build-preview command. 
    #customCommand: 'run build-preview export $(Build.Repository.LocalPath) /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/GartnerMQ2021/providers/Microsoft.DataFactory/factories/Dev-GartnerMQ2021-DataFactory "ArmTemplate"'
     displayName: 'Validate and Generate ARM template'
   
   # Publish the artifact to be used as a source for a release pipeline.
   
   - task: PublishPipelineArtifact@1
     inputs:
       targetPath: '$(Build.Repository.LocalPath)/<folder-of-the-package.json-file>/ArmTemplate' #replace with the package.json folder
       artifact: 'ArmTemplates'
       publishLocation: 'pipeline'
   

4. Entrez votre code YAML. Utilisez le fichier YAML comme point de départ.

5. Enregistrez et exécutez. Si vous avez utilisé le YAML, il se déclenche à chaque mise à jour de la branche primaire. Confirmez que la course réussit et produit l’artefact ArmTemplates dans les artefacts publiés dans le pipeline.

Contenu connexe

En savoir plus sur l’intégration continue et la livraison dans Data Factory : intégration continue et livraison dans Azure Data Factory.