DataWorks:Synchronisation et fusion de code Git

Étape 1 : Préparer les ressources et le réseau

Les tâches de synchronisation de code s'exécutent sur un groupe de ressources serverless et nécessitent un accès réseau à votre dépôt Git et à OSS.

1. Préparez un groupe de ressources serverless et configurez le réseau.

   • Préparez un groupe de ressources serverless DataWorks et associez-le à l'espace de travail cible.

   • Assurez-vous que le groupe de ressources peut accéder au port SSH du serveur Git. Seul le port 22 est pris en charge.

     • Dépôt Git public (par exemple, Alibaba Cloud DevOps CodeUp ou GitHub.com) : Configurez une passerelle NAT Internet et une adresse IP élastique (EIP) pour le VPC du groupe de ressources afin d'activer l'accès au réseau public.

     • Dépôt Git privé : Assurez-vous que le groupe de ressources et le serveur Git peuvent communiquer via le réseau privé (VPC). Pour plus d'informations, consultez les solutions de connectivité réseau.

2. Préparez une source de données OSS. La fonctionnalité de synchronisation de code utilise OSS pour le stockage temporaire.

   • Créez un bucket OSS dans la même région que l'espace de travail DataWorks.

   • Sur la page Data Source Management de l'espace de travail DataWorks, créez une source de données OSS pointant vers le bucket.

     Remarque

     Assurez-vous que les identifiants d'accès utilisés par la source de données OSS disposent des autorisations suivantes : oss:GetObject, oss:ListObjects, oss:PutObject et oss:DeleteObject.

Étape 2 : Préparer l'environnement Git

Créez un compte dédié sur la plateforme Git, configurez les clés SSH et définissez les règles de protection des branches.

1. Créez un compte Git dédié et générez des clés SSH.

   1. Créez un compte sur la plateforme Git (par exemple, Alibaba Cloud DevOps CodeUp ou GitLab) dédié aux validations automatiques de code (par exemple, dataworks_pusher), et configurez une adresse e-mail valide.

   2. Générez une paire de clés SSH en mode algorithme RSA pour ce compte. Ne définissez pas de phrase secrète (passphrase) lors de la génération des clés.

      • Objectif : Générer la clé publique et la clé privée SSH pour l'authentification.

      • Commande :

        # Replace "your_user_email@example.com" with the account email configured in the previous step
        ssh-keygen -t rsa -C "your_user_email@example.com"
        
        # When prompted for a passphrase, press Enter to skip
        # Enter passphrase (empty for no passphrase): [Enter]
        # Enter same passphrase again: [Enter]

      • Résultat : Après l'exécution de la commande, les fichiers id_rsa (clé privée) et id_rsa.pub (clé publique) sont générés dans le répertoire ~/.ssh/. Le contenu de ces deux fichiers sera utilisé dans les étapes suivantes.

        # Copy and save the public and private key contents, which will be needed in later steps
        cat ~/.ssh/id_rsa.pub
        cat ~/.ssh/id_rsa

2. Ajoutez la clé publique sur la plateforme Git.

   Connectez-vous à la plateforme Git et ajoutez la clé publique générée à l'étape précédente (le contenu du fichier id_rsa.pub) sur la page de gestion des clés SSH du compte dataworks_pusher.

3. Créez un dépôt de code et configurez les règles de protection des branches.

   1. Créez un dépôt Git dédié à la gestion du code DataWorks, par exemple DataWorks_code.

   2. Configurez des règles de protection des branches dans le dépôt pour empêcher les modifications directes des branches gérées automatiquement par DataWorks. Cette opération doit être effectuée par un administrateur du dépôt.

      Important

      Des règles de protection de branche mal configurées peuvent entraîner la modification accidentelle des branches gérées automatiquement par DataWorks, ce qui rompt la cohérence de la synchronisation.

      • Motif de nom de branche : dataworks_*

      • Autorisé à pousser (Push) : Sélectionnez des membres spécifiés et ajoutez le compte dataworks_pusher.

      • Autorisé à fusionner (Merge) : Sélectionnez No one.

Étape 3 : Configurer et initialiser la synchronisation de code

Étape 4 : Vérifier la synchronisation de code

1. Créez un nœud Shell pour le développement de données et nommez-le shell_test.

2. Saisissez le code suivant dans l'éditeur de code et cliquez sur le bouton Save dans la barre d'outils.

   echo 'Code push test.'

3. Connectez-vous à Git, accédez au dépôt cible, sélectionnez la branche d'enregistrement (save) et localisez le dossier shell_test. Vous constaterez que le dossier contient trois fichiers : shell_test.sh (code file), shell_test.spec.json (scheduling configuration file) et dataworks.properties (variable file). Cliquez sur shell_test.sh pour afficher le nœud shell_test et son contenu de code, ce qui indique que la synchronisation a réussi.

4. Pour vérifier l'état de synchronisation des deux autres branches, déployez les nœuds dans les environnements correspondants. Pour plus d'informations sur le déploiement des nœuds, consultez la rubrique Deploy nodes.

Fusion inverse

DataWorks permet de fusionner les dernières modifications d'une branche Git distante vers la plateforme.

Cette capacité fonctionne à la fois avec la branche de synchronisation principale et les branches de fonctionnalités créées à partir de celle-ci. Les développeurs peuvent travailler sur des branches indépendantes, effectuer des revues de code, puis intégrer le code testé dans DataWorks pour une collaboration d'équipe efficace.

1. Point d'entrée de fusion

   Dans DataStudio > Code Management, développez la section Code Merge.

2. Aperçu de la fusion

   Dans la zone de saisie Branch, saisissez le nom de la branche à fusionner, par exemple feature_cn-shanghai_branch. Cliquez sur merge preview. Le système compare les ajouts, modifications et suppressions entre la branche source et la branche save DataWorks par défaut.

   • Aucun conflit : L'interface affiche un diff des modifications, listant clairement les nœuds à ajouter, modifier ou supprimer ainsi que les détails des changements de code.

   • Conflits détectés : L'interface affiche les conflits ainsi que le contenu spécifique en conflit. Dans ce cas, retournez dans votre environnement local, résolvez les conflits manuellement dans Git, puis relancez la fusion.

3. Confirmer la fusion

   1. Après avoir vérifié que l'aperçu est correct, cliquez sur Confirm merge.

   2. Le système démarre la tâche de fusion et vous pouvez surveiller la progression de la fusion en temps réel.

   3. Tous les historiques de fusion sont affichés dans la section historique de fusion de code ci-dessous. Vous pouvez consulter à tout moment le propriétaire, l'état de la fusion et les détails de la branche.

Fusion inter-espaces de travail

La synchronisation Git prend en charge le clonage de projets DataWorks entre différents espaces de travail et régions, vous permettant d'utiliser un ensemble de code standardisé comme modèle réutilisable dans divers scénarios métier. Par exemple, vous pouvez déployer un modèle d'analyse utilisateur commun dans des espaces de travail indépendants de différentes lignes métier, chacun s'exécutant sur ses propres ressources de calcul et sources de données.

1. Configuration initiale

   1. Créez deux projets : git_cross_project_1 et git_cross_project_2. La création interrégion est prise en charge.

   2. Suivez l'Étape 1 pour configurer le groupe de ressources et la source de données OSS dans chaque espace de travail. Les deux sources de données peuvent utiliser la même configuration. Configurez également la connectivité réseau.

   3. Suivez l'Étape 2 pour préparer un seul dépôt Git en tant que dépôt de gestion de code partagé pour les deux espaces de travail.

   4. Suivez l'Étape 3 pour configurer la synchronisation Git pour les deux espaces de travail (utilisez la même adresse SSH et la même clé privée pour les deux), et assurez-vous que l'initialisation réussit. À ce stade, les branches des deux espaces de travail, 270256 (project1) et 270257 (project2), apparaissent dans le dépôt Git.

2. Politique de fusion inter-projets

   1. Lors de la fusion de branches de code entre projets, seuls le code des nœuds, les propriétés de base et les configurations de planification sont fusionnés. Les configurations d'exécution ne sont pas fusionnées dans l'espace de travail cible.

   2. Étant donné que les ressources de calcul, les groupes de ressources et les sources de données utilisés par les deux espaces de travail peuvent différer, configurez un fichier de mappage de ressources merge_mapping.

      1. Ouvrez le terminal sur votre ordinateur local, clonez la branche d'enregistrement (save) de l'espace de travail source sur votre machine locale, et basculez vers la branche d'enregistrement du projet1 de l'espace de travail source, par exemple dataworks_cn_shenzhen_270256_save.

         # Clone the remote Git repository to your local machine
         git clone git@your_git_server_domain:64dc86a16800a4a57137536/cross_project_shenzhen.git
         
         # Switch to the save branch of project1
         git checkout <your branch name>

      2. Créez le fichier de mappage merge_mapping.

         # cross_project_shenzhen is the repository name
         cd cross_project_shenzhen 
         
         # Create the directory
         mkdir -p DATAWORKS_SYSTEM_CONFIG/merge_mapping
         
         # Create the mapping file, e.g., cn_shenzhen_270256_to_cn_shenzhen_270257.properties
         vi DATAWORKS_SYSTEM_CONFIG/merge_mapping/<region>_<projectId>_to_<region>_<projectId>.properties

         Configurez le contenu du fichier en fonction de votre configuration réelle. Modifiez les valeurs réelles de part et d'autre de =. Plusieurs valeurs sont prises en charge pour chaque type.

         # Data source
         # spec.datasource.name.<project1 data source name>=<project2 data source name>
         spec.datasource.name.mysql_01=mysql_02
         
         # Resource group
         # spec.runtimeResource.resourceGroup.<project1 resource group ID>=<project2 resource group ID>
         spec.runtimeResource.resourceGroup.group_524257424564736=Serverless_res_group_524257424564736_764027070300961
         
         # Node output name prefix
         # spec.output-prefix.<project1 name>=<project2 name>
         spec.output-prefix.git_cross_project_1=git_cross_project_2
         
         # Project prefix for tables in MaxCompute SQL
         # script.project-identifier.<project1 name>=<project2 name>
         script.project-identifier.git_cross_project_1=git_cross_project_2
         
         # Image
         # spec.script.runtime.container.imageId.<image ID used in project1>=<image ID used in project2>
         spec.script.runtime.container.imageId.Default=System_python311_ubuntu2204_20251201
         
         # RAM role
         # spec.script.runtime.linkedRoleArn.<RAM role ARN used in project1>=<RAM role ARN used in project2>
         spec.script.runtime.linkedRoleArn.acs:ram::1107550004253538:role/aliyundataworksaccessingenirole=acs:ram::1107550004253538:role/aliyundataworksaccessingossrole

         Poussez le code vers le dépôt Git.

         # Stage current directory changes in git
         git add .
         # Commit the mapping file
         git commit -m "add mapping files"
         # Push the branch content to the remote Git repository
         git push

   3. Fusionnez le code entre les projets

      1. Accédez à DataStudio de l'espace de travail cible git_cross_project_2. Cliquez sur Code Management dans le volet de navigation de gauche, et localisez l'onglet Code Merge.

      2. Dans la zone de saisie de branche, saisissez le nom de la branche d'enregistrement (save) de l'espace de travail source, par exemple dataworks_cn_shenzhen_270256_save.

      3. Cliquez sur merge preview. Après avoir confirmé que l'aperçu est correct, fusionnez le code de l'espace de travail git_cross_project_1 vers l'espace de travail git_cross_project_2. Pour plus de détails sur l'opération de fusion, consultez la section Fusion de Git vers DataWorks.