Configurer un pipeline CI/CD pour votre workflow de traitement des données

Last reviewed 2023-04-20 UTC

---

Ce tutoriel explique comment configurer un pipeline d'intégration/de déploiement continu (CI/CD) pour le traitement des données en appliquant des méthodes CI/CD à l'aide de produits gérés sur Google Cloud. Les data scientists et les analystes peuvent adapter les méthodologies mises en œuvre dans les pratiques CI/CD pour garantir la haute qualité, la facilité de gestion et l'adaptabilité des processus de données et des workflows. Vous pouvez appliquer les méthodes suivantes :

• Contrôle des versions du code source
• Création, test et déploiement automatiques d'applications
• Isolation et séparation des environnements de développement et de test de l'environnement de production
• Procédures reproductibles pour la configuration des environnements

Ce tutoriel est destiné aux data scientists et aux analystes qui créent et exécutent des tâches récurrentes de traitement des données afin de structurer leurs activités de recherche et développement (R&D), et de gérer de manière systématique et automatique les charges de travail de traitement des données.

Architecture de déploiement

Dans ce guide, vous allez utiliser les produits Google Cloud suivants :

• Cloud Build, pour développer un pipeline CI/CD afin de créer, déployer et tester un workflow de traitement des données, et effectuer le traitement des données. Cloud Build est un service géré qui exécute votre build sur Google Cloud sous la forme d'une série d'étapes de compilation où chaque étape est exécutée dans un conteneur Docker.
• Cloud Composer, pour définir et exécuter les étapes du workflow, telles que le démarrage du traitement des données, le test et la vérification des résultats. Cloud Composer est un service géré basé sur Apache Airflow qui offre un environnement dans lequel vous pouvez créer, planifier, surveiller et gérer des workflows complexes, tels que le workflow de traitement des données développé dans ce tutoriel.
• Cloud Dataflow pour exécuter l'exemple Apache Beam WordCount comme exemple de traitement des données.

Le pipeline CI/CD

De manière générale, le pipeline CI/CD comprend les étapes suivantes :

1. Cloud Build crée un package de l'exemple WordCount dans un fichier JAR (Java Archive) à exécution automatique à l'aide du compilateur Maven. Le compilateur Maven est un conteneur dans lequel Maven est installé. Lorsqu'une étape de compilation est configurée pour utiliser le compilateur Maven, Maven exécute les tâches.
2. Cloud Build importe le fichier JAR dans Cloud Storage.
3. Cloud Build exécute des tests unitaires sur le code du workflow de traitement des données et déploie le code du workflow dans Cloud Composer.
4. Cloud Composer récupère le fichier JAR et exécute la tâche de traitement des données sur Cloud Dataflow.

Le schéma suivant présente une vue détaillée des étapes du pipeline CI/CD.

Dans ce tutoriel, les déploiements dans les environnements de test et de production sont séparés en deux pipelines Cloud Build différents : un pipeline de test et un pipeline de production.

Dans le schéma précédent, le pipeline de test comprend les étapes suivantes :

1. Un développeur valide les modifications de code dans Cloud Source Repositories.
2. Les modifications de code déclenchent une compilation test dans Cloud Build.
3. Cloud Build crée le fichier JAR auto-exécutable et le déploie dans le bucket JAR de test sur Cloud Storage.
4. Cloud Build déploie les fichiers de test dans les buckets de fichiers de test sur Cloud Storage.
5. Cloud Build définit dans Cloud Composer la variable utilisée pour référencer le fichier JAR qui vient d'être déployé.
6. Cloud Build teste le graphe orienté acyclique (DAG, Directed Acyclic Graph) du workflow de traitement des données et le déploie dans le bucket Cloud Composer sur Cloud Storage.
7. Le fichier DAG du workflow est déployé dans Cloud Composer.
8. Cloud Build déclenche l'exécution du workflow de traitement des données qui vient d'être déployé.
9. Une fois le test d'intégration du workflow de traitement des données passé, un message est publié dans Pub/Sub contenant une référence au dernier fichier JAR auto-exécutable (obtenu à partir des variables Airflow) dans les données du message.

Dans le schéma précédent, le pipeline de production comprend les étapes suivantes :

1. Le pipeline de déploiement en production est déclenché lorsqu'un message est publié dans un sujet Pub/Sub.
2. Un développeur approuve manuellement le pipeline de déploiement en production et la compilation est exécutée.
3. Cloud Build copie le dernier fichier JAR auto-exécutable à partir du bucket JAR de test vers le bucket JAR de production sur Cloud Storage.
4. Cloud Build teste le DAG du workflow de production de traitement des données et le déploie dans le bucket Cloud Composer sur Cloud Storage.
5. Le fichier DAG du workflow de production est déployé dans Cloud Composer.

Dans ce tutoriel, le workflow de production est déployé dans le même environnement Cloud Composer que le workflow de test afin de fournir une vue consolidée de tous les workflows. Pour les besoins de ce tutoriel, différents buckets Cloud Storage sont utilisés pour stocker les données d'entrée et de sortie afin de séparer les deux environnements.

Pour séparer complètement les deux environnements, vous devez créer plusieurs environnements Cloud Composer dans différents projets, séparés par défaut les uns des autres. Cette séparation permet de sécuriser votre environnement de production. Cette approche n'entre pas dans le cadre de ce tutoriel. Pour en savoir plus sur l'accès aux ressources de plusieurs projets Google Cloud, consultez la page Définir des autorisations de compte de service.

Le workflow de traitement des données

Les instructions relatives à l'exécution du workflow de traitement des données par Cloud Composer sont définies dans un graphe orienté acyclique (DAG) écrit en Python. Le DAG définit toutes les étapes du workflow de traitement des données, ainsi que les dépendances entre elles.

Le pipeline CI/CD déploie automatiquement la définition du DAG à partir de Cloud Source Repositories dans Cloud Composer, dans chaque compilation. Ce processus garantit que Cloud Composer est toujours à jour avec la dernière définition du workflow sans qu'aucune intervention humaine ne soit requise.

En plus du workflow de traitement des données, la définition du DAG pour l'environnement de test comprend une étape de test de bout en bout. Cette étape de test permet de vérifier que le workflow de traitement des données s'exécute correctement.

Le workflow de traitement des données est illustré dans le schéma suivant.

Le workflow de traitement des données comprend les étapes suivantes :

1. Exécution du processus de données WordCount dans Dataflow.

2. Téléchargement des trois fichiers de sortie générés par le processus WordCount :

   • download_result_1
   • download_result_2
   • download_result_3

3. Téléchargement du fichier de référence appelé download_ref_string.

4. Vérification des résultats par rapport au fichier de référence. Ce test d'intégration agrège les trois résultats et compare les résultats agrégés au fichier de référence.

5. Publication d'un message sur Pub/Sub une fois que le test d'intégration a réussi.

L'utilisation d'un framework d'orchestration de tâches, tel que Cloud Composer, pour gérer le workflow de traitement des données permet de réduire la complexité du code du workflow.

Les tests

Outre le test d'intégration qui vérifie le workflow de traitement des données de bout en bout, ce tutoriel comporte deux tests unitaires. Les tests unitaires sont des tests automatiques exécutés sur le code de traitement des données et le code du workflow de traitement des données. Le test sur le code de traitement des données est écrit en Java et s'exécute automatiquement lors du processus de compilation Maven. Le test sur le code du workflow de traitement des données est écrit en Python et s'exécute en tant qu'étape de compilation indépendante.

Objectifs

• Configurer l'environnement Cloud Composer
• Créer des buckets Cloud Storage pour vos données
• Créer les pipelines de compilation, de test et de production
• Configurer le déclencheur de compilation

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

• Cloud Source Repositories
• Cloud Build
• Cloud Composer
• Dataflow
• Cloud Storage

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

   Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

   Accéder au sélecteur de projet

3. Vérifiez que la facturation est activée pour votre projet Google Cloud.

4. Activer les API Cloud Build, Cloud Source Repositories, Cloud Composer, and Dataflow.

   Activer les API

5. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

   Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

   Accéder au sélecteur de projet

6. Vérifiez que la facturation est activée pour votre projet Google Cloud.

7. Activer les API Cloud Build, Cloud Source Repositories, Cloud Composer, and Dataflow.

   Activer les API

Exemple de code

L'exemple de code se trouve dans deux dossiers :

• Le dossier env-setup contient des scripts shell pour la configuration initiale de l'environnement Google Cloud.

• Le dossier source-code contient du code qui est développé au fil du temps, qui doit être contrôlé par la source et déclenche des processus automatiques de compilation et de test. Ce dossier contient les sous-dossiers suivants :

  • Le dossier data-processing-code contient le code source du processus Apache Beam.
  • Le dossier workflow-dag contient les définitions DAG de Cloud Composer pour les workflows de traitement des données, ainsi que les étapes de conception, de mise en œuvre et de test du processus Cloud Dataflow.
  • Le dossier build-pipeline contient deux configurations Cloud Build, l'une pour le pipeline de test et l'autre pour le pipeline de production. Ce dossier contient également un script d'assistance pour les pipelines.

Dans le cadre de ce tutoriel, les fichiers de code source pour le traitement des données et pour le workflow DAG se trouvent dans des dossiers différents du même dépôt de code source. Dans un environnement de production, les fichiers de code source se trouvent généralement dans leurs propres dépôts de code source, et sont gérés par des équipes différentes.

Configurer l'environnement

Dans ce tutoriel, vous allez exécuter toutes les commandes dans Cloud Shell. Cloud Shell apparaît sous la forme d'une fenêtre en bas de Google Cloud Console.

1. Dans Google Cloud Console, ouvrez Cloud Shell :

   Ouvrir Cloud Shell

2. Clonez l'exemple de dépôt de code :

   git clone https://github.com/GoogleCloudPlatform/ci-cd-for-data-processing-workflow.git
   

3. Exécutez un script pour définir les variables d'environnement :

   cd ~/ci-cd-for-data-processing-workflow/env-setup
   source set_env.sh
   

   Le script définit les variables d'environnement suivantes :

   • L'ID de votre projet Google Cloud
   • Votre région et votre zone
   • Le nom des buckets Cloud Storage utilisés par le pipeline de compilation et le workflow de traitement des données

   Comme les variables d'environnement ne sont pas conservées entre les sessions, si votre session Cloud Shell se ferme ou se déconnecte pendant que vous suivez le tutoriel, vous devez reconfigurer les variables d'environnement.

Créer l'environnement Cloud Composer

Dans ce tutoriel, vous allez configurer un environnement Cloud Composer.

1. Dans Cloud Shell, ajoutez le rôle Extension de l'agent de service de l'API Cloud Composer v2 (roles/composer.ServiceAgentV2Ext) au compte d'agent de service Cloud Composer:

   gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
       --member serviceAccount:service-$[e-mail] \
       --role roles/composer.ServiceAgentV2Ext
   

2. Dans Cloud Shell, créez l'environnement Cloud Composer :

   gcloud composer environments create $COMPOSER_ENV_NAME \
       --location $COMPOSER_REGION \
       --image-version composer-2.0.14-airflow-2.2.5
   

   Remarque : La mise en service de l'environnement Cloud Composer prend environ 15 minutes, mais peut durer jusqu'à une heure. Attendez la fin de l'opération avant de passer aux étapes suivantes.

3. Exécutez un script pour définir les variables de l'environnement Cloud Composer. Les variables sont requises pour les DAG de traitement des données.

   cd ~/ci-cd-for-data-processing-workflow/env-setup
   chmod +x set_composer_variables.sh
   ./set_composer_variables.sh
   

   Le script définit les variables d'environnement suivantes :

   • L'ID de votre projet Google Cloud
   • Votre région et votre zone
   • Le nom des buckets Cloud Storage utilisés par le pipeline de compilation et le workflow de traitement des données

Extraire les propriétés de l'environnement Cloud Composer

Cloud Composer utilise un bucket Cloud Storage pour stocker les DAG. Le déplacement d'un fichier de définition de DAG vers ce bucket déclenche la lecture automatique des fichiers par Cloud Composer. Vous avez créé le bucket Cloud Storage pour Cloud Composer lorsque vous avez créé l'environnement Cloud Composer. Dans la procédure suivante, vous allez extraire l'URL des buckets, puis configurer votre pipeline CI/CD pour déployer automatiquement les définitions de DAG dans le bucket Cloud Storage.

1. Dans Cloud Shell, exportez l'URL du bucket en tant que variable d'environnement :

   export COMPOSER_DAG_BUCKET=$(gcloud composer environments describe $COMPOSER_ENV_NAME \
       --location $COMPOSER_REGION \
       --format="get(config.dagGcsPrefix)")
   

2. Exportez le nom du compte de service utilisé par Cloud Composer pour accéder aux buckets Cloud Storage :

   export COMPOSER_SERVICE_ACCOUNT=$(gcloud composer environments describe $COMPOSER_ENV_NAME \
       --location $COMPOSER_REGION \
       --format="get(config.nodeConfig.serviceAccount)")
   

Créer les buckets Cloud Storage

Dans cette section, vous allez créer un ensemble de buckets Cloud Storage pour stocker les éléments suivants :

• Artefacts des étapes intermédiaires du processus de compilation
• Fichiers d’entrée et de sortie du workflow de traitement des données
• Emplacement de préproduction des tâches Cloud Dataflow dans lequel stocker leurs fichiers binaires

Pour créer les buckets Cloud Storage, procédez comme suit :

• Dans Cloud Shell, créez des buckets Cloud Storage, et accordez au compte de service Cloud Composer l'autorisation d'exécuter les workflows de traitement des données :

  cd ~/ci-cd-for-data-processing-workflow/env-setup
  chmod +x create_buckets.sh
  ./create_buckets.sh
  

Créer le sujet Pub/Sub

Dans cette section, vous allez créer un sujet Pub/Sub destiné à recevoir les messages envoyés depuis le test d'intégration du workflow de traitement des données afin de déclencher automatiquement le pipeline de compilation en production.

1. Dans la console Google Cloud, accédez à la page Sujets Pub/Sub.

   Accéder à la page Rubrique

2. Cliquez sur Créer un sujet.

3. Pour configurer le sujet, procédez comme suit :

   • Pour l'ID du sujet, saisissez integration-test-complete-topic.
   • Vérifiez que l'option Ajouter un abonnement par défaut est cochée.
   • Laissez les autres options décochées.
   • Dans le champ Chiffrement, sélectionnez Clé de chiffrement gérée par Google.
   • Cliquez sur Créer un sujet.

   

Transférer le code source vers Cloud Source Repositories

Dans ce tutoriel, vous disposez d'un base de code source que vous devez intégrer au contrôle des versions. L'étape suivante montre comment une base de code est développée et évolue au fil du temps. Chaque envoi de modifications dans le dépôt déclenche le pipeline de compilation, de déploiement et de test.

• Dans Cloud Shell, placez le dossier source-code dans Cloud Source Repositories :

  gcloud source repos create $SOURCE_CODE_REPO
  cp -r ~/ci-cd-for-data-processing-workflow/source-code ~/$SOURCE_CODE_REPO
  cd ~/$SOURCE_CODE_REPO
  git init
  git remote add google \
      https://source.developers.google.com/p/$GCP_PROJECT_ID/r/$SOURCE_CODE_REPO
  git add .
  git commit -m 'initial commit'
  git push google master
  

  Il s'agit de commandes standards permettant d'initialiser Git dans un nouveau répertoire et de transférer le contenu vers un dépôt distant.

Créer des pipelines Cloud Build

Dans cette section, vous allez créer les pipelines de compilation qui créent, déploient et testent le workflow de traitement des données.

Accorder l'accès au compte de service Cloud Build

Cloud Build déploie des DAG Cloud Composer et déclenche des workflows, qui sont activés lorsque vous ajoutez un accès supplémentaire au compte de service Cloud Build. Pour en savoir plus sur les différents rôles disponibles lorsque vous utilisez Cloud Composer, consultez la documentation sur le contrôle des accès.

1. Dans Cloud Shell, ajoutez le rôle composer.admin au compte de service Cloud Build afin que la tâche Cloud Build puisse définir des variables Airflow dans Cloud Composer :

   gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
       --member=serviceAccount:$[e-mail] \
       --role=roles/composer.admin
   

2. Ajoutez le rôle composer.worker au compte de service Cloud Build afin que la tâche Cloud Build puisse déclencher le workflow de données dans Cloud Composer :

   gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
       --member=serviceAccount:$[e-mail] \
       --role=roles/composer.worker
   

Créer le pipeline de compilation et de test

Les étapes du pipeline de compilation et de test sont configurées dans le fichier de configuration YAML. Dans ce tutoriel, vous allez utiliser les images de compilateur précompilées pour git, maven, gsutil et gcloud afin d'exécuter les tâches de chaque étape de compilation. Vous allez utiliser des substitutions de variables de configuration pour définir les paramètres d'environnement au moment de la compilation. L'emplacement du dépôt contenant le code source est défini par les substitutions de variables, ainsi que par l'emplacement des buckets Cloud Storage. La compilation a besoin de ces informations pour déployer le fichier JAR, les fichiers de test et la définition du DAG.

• Dans Cloud Shell, envoyez le fichier de configuration du pipeline de compilation pour créer le pipeline dans Cloud Build :

  cd ~/ci-cd-for-data-processing-workflow/source-code/build-pipeline
  gcloud builds submit --config=build_deploy_test.yaml --substitutions=\
  REPO_NAME=$SOURCE_CODE_REPO,\
  _DATAFLOW_JAR_BUCKET=$DATAFLOW_JAR_BUCKET_TEST,\
  _COMPOSER_INPUT_BUCKET=$INPUT_BUCKET_TEST,\
  _COMPOSER_REF_BUCKET=$REF_BUCKET_TEST,\
  _COMPOSER_DAG_BUCKET=$COMPOSER_DAG_BUCKET,\
  _COMPOSER_ENV_NAME=$COMPOSER_ENV_NAME,\
  _COMPOSER_REGION=$COMPOSER_REGION,\
  _COMPOSER_DAG_NAME_TEST=$COMPOSER_DAG_NAME_TEST
  

  Cette commande indique à Cloud Build d’exécuter une compilation selon la procédure suivante :

  1. Créer et déployer le fichier JAR WordCount auto-exécutable.

     1. Vérifier le code source.
     2. Compiler le code source Beam WordCount dans un fichier JAR auto-exécutable.
     3. Stocker le fichier JAR sur Cloud Storage où il peut être sélectionné par Cloud Composer pour exécuter la tâche de traitement WordCount.

  2. Déployer et configurer le workflow de traitement des données sur Cloud Composer.

     1. Exécuter le test unitaire sur le code opérateur personnalisé utilisé par le DAG du workflow.
     2. Déployer le fichier d'entrée du test et le fichier de référence du test sur Cloud Storage. Le fichier d'entrée du test contient les données d'entrée de la tâche de traitement WordCount. Le fichier de référence du test sert de référence pour vérifier le résultat de la tâche de traitement WordCount.
     3. Définir les variables Cloud Composer de sorte qu'elles pointent vers le fichier JAR qui vient d'être créé.
     4. Déployer la définition du DAG du workflow dans l'environnement Cloud Composer.

  3. Exécuter le workflow de traitement de données dans l'environnement de test pour déclencher le workflow de traitement de test.

Vérifier le pipeline de compilation et de test

Après avoir envoyé le fichier de compilation, vérifiez les étapes de compilation.

1. Dans la console Google Cloud, accédez à la page Historique de compilation pour afficher la liste de toutes les compilations précédentes et en cours d'exécution.

   Accéder à la page "Historique de compilation"

2. Cliquez sur la version en cours d'exécution.

3. Sur la page Informations sur le build, vérifiez que les étapes de compilation correspondent aux étapes décrites précédemment.

   

   Sur la page Informations sur le build, le champ État du build indique Build successful lorsque la compilation est terminée.

4. Dans Cloud Shell, vérifiez que le fichier JAR de l'exemple WordCount a été copié dans le bucket approprié :

   gsutil ls gs://$DATAFLOW_JAR_BUCKET_TEST/dataflow_deployment*.jar
   

   Le résultat ressemble à ce qui suit :

   gs://…-composer-dataflow-source-test/dataflow_deployment_e88be61e-50a6-4aa0-beac-38d75871757e.jar
   

5. Obtenez l'URL de votre interface Web Cloud Composer. Notez-la car elle sera utilisée à l'étape suivante.

   gcloud composer environments describe $COMPOSER_ENV_NAME \
       --location $COMPOSER_REGION \
       --format="get(config.airflowUri)"
   

6. Utilisez l'URL de l'étape précédente pour accéder à l'interface utilisateur de Cloud Composer afin de vérifier que le DAG s'est exécuté avec succès. Si la colonne Runs (Exécutions) n’affiche aucune information, attendez quelques minutes et actualisez la page.

   1. Pour vérifier que le DAG du workflow de traitement des données (test_word_count) est déployé et en mode d'exécution, maintenez le pointeur sur le cercle vert clair situé en dessous de Runs (Exécutions) et vérifiez qu'il affiche En cours d'exécution.

      

   2. Pour afficher le workflow de traitement des données sous forme de graphique, cliquez sur le cercle vert clair, puis sur la page DAG Runs (Exécutions DAG), cliquez sur ID du DAG : test_word_count.

   3. Actualisez la page Graph View (Vue graphique) pour mettre à jour l'état d'exécution du DAG en cours. L'exécution du workflow prend généralement entre trois et cinq minutes. Pour vérifier que l'exécution du DAG a bien été effectuée, maintenez le pointeur sur chaque tâche pour vérifier que l'info-bulle indique State: success (État : Opération réussie). L'avant-dernière tâche, appelée do_comparison, correspond au test d'intégration qui vérifie le résultat du processus par rapport au fichier de référence.

7. Une fois le test d'intégration terminé, la dernière tâche, appelée publish_test_complete, publie un message dans le sujet Pub/Sub integration-test-complete-topic, qui sera utilisé pour déclencher le pipeline de compilation en production.

   1. Pour vérifier que le message publié contient la référence correcte au dernier fichier JAR, nous pouvons extraire le message de l'abonnement Pub/Sub integration-test-complete-topic-sub par défaut.

   2. Dans la console Google Cloud, accédez à la page Abonnements.

      Accéder à la page Abonnements

   3. Cliquez sur integration-test-complete-topic-sub, sélectionnez l'onglet Message, puis cliquez sur Extraire.

   4. Le résultat doit se présenter comme suit :

      

Créer le pipeline de production

Lorsque le workflow de traitement de test s'exécute avec succès, vous pouvez faire passer la version actuelle du workflow en production. Il existe plusieurs manières de déployer le workflow en production :

• Manuellement
• Par déclenchement automatique lorsque tous les tests sont concluants dans les environnements de test ou de prépoduction
• Par déclenchement automatique provoqué par une tâche planifiée

Dans ce tutoriel, vous déclenchez automatiquement la compilation en production lorsque tous les tests sont concluants dans l'environnement de test. Pour en savoir plus sur les approches automatisées, consultez la page Ingénierie des versions.

Avant de mettre en œuvre l'approche automatisée, vous devez vérifier la compilation du déploiement de production en effectuant un déploiement manuel en production. La version de déploiement de production suit les étapes ci-dessous :

1. Copier le fichier JAR WordCount à partir du bucket de test dans le bucket de production.
2. Définir les variables Cloud Composer du workflow de production pour pointer vers le fichier JAR récemment passé en production.
3. Déployer la définition du DAG du workflow de production dans l'environnement Cloud Composer et exécuter le workflow.

Les substitutions de variables définissent le nom du dernier fichier JAR déployé en production avec les buckets Cloud Storage utilisés par le workflow de traitement de production. Pour créer le pipeline Cloud Build qui déploie le workflow Airflow de production, procédez comme suit :

1. Dans Cloud Shell, lisez le nom du dernier fichier JAR en imprimant la variable Cloud Composer correspondant au nom du fichier JAR :

   export DATAFLOW_JAR_FILE_LATEST=$(gcloud composer environments run $COMPOSER_ENV_NAME \
       --location $COMPOSER_REGION variables get -- \
       dataflow_jar_file_test 2>&1 | grep -i '.jar')
   

2. Utilisez le fichier de configuration du pipeline de compilation, deploy_prod.yaml,, pour créer le pipeline dans Cloud Build :

   cd ~/ci-cd-for-data-processing-workflow/source-code/build-pipeline
   gcloud builds submit --config=deploy_prod.yaml --substitutions=\
   REPO_NAME=$SOURCE_CODE_REPO,\
   _DATAFLOW_JAR_BUCKET_TEST=$DATAFLOW_JAR_BUCKET_TEST,\
   _DATAFLOW_JAR_FILE_LATEST=$DATAFLOW_JAR_FILE_LATEST,\
   _DATAFLOW_JAR_BUCKET_PROD=$DATAFLOW_JAR_BUCKET_PROD,\
   _COMPOSER_INPUT_BUCKET=$INPUT_BUCKET_PROD,\
   _COMPOSER_ENV_NAME=$COMPOSER_ENV_NAME,\
   _COMPOSER_REGION=$COMPOSER_REGION,\
   _COMPOSER_DAG_BUCKET=$COMPOSER_DAG_BUCKET,\
   _COMPOSER_DAG_NAME_PROD=$COMPOSER_DAG_NAME_PROD
   

Vérifier le workflow de traitement des données créé par le pipeline de production

1. Obtenez l'URL de votre interface utilisateur Cloud Composer :

   gcloud composer environments describe $COMPOSER_ENV_NAME \
       --location $COMPOSER_REGION \
       --format="get(config.airflowUri)"
   

2. Pour vérifier que le DAG du workflow de production de traitement des données est déployé, accédez à l'URL que vous avez récupérée à l'étape précédente et vérifiez que le DAG prod_word_count figure dans la liste des DAG.

   1. Sur la page des DAG, dans la ligne prod_word_count, cliquez sur Trigger DAG (Déclencher le DAG).

      

3. Cliquez sur le logo Airflow ou actualisez la page pour mettre à jour l'état d'exécution du DAG. Un cercle vert clair dans la colonne Exécutions indique que le DAG est en cours d'exécution. Maintenez le pointeur sur le cercle pour afficher l'info-bulle indiquant En cours d'exécution.

   

4. Une fois l'exécution réussie, maintenez le pointeur sur le cercle vert foncé situé sous la colonne Exécutions DAG et vérifiez qu'il affiche l'état Opération réussie.

   

5. Dans Cloud Shell, répertoriez les fichiers de résultats dans le bucket Cloud Storage :

   gsutil ls gs://$RESULT_BUCKET_PROD
   

   Le résultat ressemble à ce qui suit :

   gs://…-composer-result-prod/output-00000-of-00003
   gs://…-composer-result-prod/output-00001-of-00003
   gs://…-composer-result-prod/output-00002-of-00003
   

Remarque : En général, lorsque l'exécution des tâches de workflow de données en production est déclenchée par des événements, tels que la publication de messages Pub/Sub ou le stockage de fichiers dans des buckets, ou est programmée pour s'exécuter de manière régulière, il est important que la tâche de déploiement vérifie que le workflow de données en production n'est pas en cours d'exécution avant le déploiement. Dans un environnement de production, vous pouvez utiliser dag_state, l'une des commandes CLI Airflow, pour récupérer l'état d'exécution d'un DAG.

Créer les déclencheurs Cloud Build

Dans cette section, vous allez créer le déclencheur Cloud Build qui lie les modifications du code source au processus de compilation de test et celui situé entre le pipeline de test et le pipeline de compilation en production.

Configurer le déclencheur du pipeline de compilation de test

Vous allez configurer un déclencheur Cloud Build qui déclenche une nouvelle compilation lorsque les modifications sont envoyées dans la branche principale du dépôt source.

1. Dans la console Google Cloud, accédez à la page Déclencheurs de compilation.

   Accéder à la page "Déclencheurs de compilation"

2. Cliquez sur Créer un déclencheur.

3. Pour configurer les paramètres du déclencheur, procédez comme suit :

   • Dans le champ Nom, saisissez trigger-build-in-test-environment.
   • Dans la liste déroulante Région, sélectionnez global (non régional).
   • Pour Événement, cliquez sur Déployer sur une branche.
   • Pour Source, sélectionnez data-pipeline-source.
   • Dans le champ Nom de la branche, saisissez master.
   • Pour le champ Configuration, cliquez sur Fichier de configuration Cloud Build (yaml ou json).
   • Pour le champ Emplacement, cliquez sur Dépôt.
   • Dans le champ Emplacement du fichier de configuration Cloud Build, saisissez build-pipeline/build_deploy_test.yaml.

4. Dans Cloud Shell, exécutez la commande suivante pour obtenir toutes les variables de substitution nécessaires à la compilation. Notez ces valeurs car vous en aurez besoin ultérieurement.

   echo "_COMPOSER_DAG_BUCKET : ${COMPOSER_DAG_BUCKET}
   _COMPOSER_DAG_NAME_TEST : ${COMPOSER_DAG_NAME_TEST}
   _COMPOSER_ENV_NAME : ${COMPOSER_ENV_NAME}
   _COMPOSER_INPUT_BUCKET : ${INPUT_BUCKET_TEST}
   _COMPOSER_REF_BUCKET : ${REF_BUCKET_TEST}
   _COMPOSER_REGION : ${COMPOSER_REGION}
   _DATAFLOW_JAR_BUCKET : ${DATAFLOW_JAR_BUCKET_TEST}"
   

   Remarque : La paire nom/valeur de sortie est utilisée pour l'étape suivante.

5. Sur la page Paramètres du déclencheur, sous Avancé, Variables de substitution, remplacez les variables par les valeurs correspondant à votre environnement, que vous avez obtenues à l'étape précédente. Ajoutez les éléments suivants un à un, puis cliquez sur + Ajouter un élément pour chacune des paires nom-valeur.

   • _COMPOSER_DAG_BUCKET
   • _COMPOSER_DAG_NAME_TEST
   • _COMPOSER_ENV_NAME
   • _COMPOSER_INPUT_BUCKET
   • _COMPOSER_REF_BUCKET
   • _COMPOSER_REGION

   • _DATAFLOW_JAR_BUCKET

     

6. Cliquez sur Créer.

Configurer le déclencheur du pipeline de compilation en production

Vous allez configurer un déclencheur Cloud Build qui déclenche une compilation en production lorsque les tests sont concluants dans l'environnement de test et qu'un message est publié dans le sujet Pub/Sub tests-complete. Ce déclencheur comprend une étape d'approbation au cours de laquelle la compilation doit être approuvée manuellement avant l'exécution du pipeline de production.

1. Dans la console Google Cloud, accédez à la page Déclencheurs de compilation.

   Accéder à la page "Déclencheurs de compilation"

2. Cliquez sur Créer un déclencheur.

3. Pour configurer les paramètres du déclencheur, procédez comme suit :

   • Dans le champ Nom, saisissez trigger-build-in-prod-environment.
   • Dans la liste déroulante Région, sélectionnez global (non régional).
   • Pour le champ Événement, cliquez sur Message Pub/Sub.
   • Pour Abonnement, sélectionnez integration-test-complete-topic.
   • Pour Source, sélectionnez data-pipeline-source.
   • Pour Révision, sélectionnez Branche.
   • Dans le champ Nom de la branche, saisissez master.
   • Pour le champ Configuration, cliquez sur Fichier de configuration Cloud Build (yaml ou json).
   • Pour le champ Emplacement, cliquez sur Dépôt.
   • Dans le champ Emplacement du fichier de configuration Cloud Build, saisissez build-pipeline/deploy_prod.yaml.

4. Dans Cloud Shell, exécutez la commande suivante pour obtenir toutes les variables de substitution nécessaires à la compilation. Notez ces valeurs car vous en aurez besoin ultérieurement.

   echo "_COMPOSER_DAG_BUCKET : ${COMPOSER_DAG_BUCKET}
   _COMPOSER_DAG_NAME_PROD : ${COMPOSER_DAG_NAME_PROD}
   _COMPOSER_ENV_NAME : ${COMPOSER_ENV_NAME}
   _COMPOSER_INPUT_BUCKET : ${INPUT_BUCKET_PROD}
   _COMPOSER_REGION : ${COMPOSER_REGION}
   _DATAFLOW_JAR_BUCKET_PROD : ${DATAFLOW_JAR_BUCKET_PROD}
   _DATAFLOW_JAR_BUCKET_TEST : ${DATAFLOW_JAR_BUCKET_TEST}"
   

   Remarque : La paire nom/valeur de sortie est utilisée pour l'étape suivante.

5. Sur la page Paramètres du déclencheur, sous Avancé, Variables de substitution, remplacez les variables par les valeurs correspondant à votre environnement, que vous avez obtenues à l'étape précédente. Ajoutez les éléments suivants un à un, puis cliquez sur + Ajouter un élément pour chacune des paires nom-valeur.

   • _COMPOSER_DAG_BUCKET
   • _COMPOSER_DAG_NAME_PROD
   • _COMPOSER_ENV_NAME
   • _COMPOSER_INPUT_BUCKET
   • _COMPOSER_REGION
   • _DATAFLOW_JAR_BUCKET_PROD
   • _DATAFLOW_JAR_BUCKET_TEST

   • _DATAFLOW_JAR_FILE_LATEST = $(body.message.data)

     

6. Pour Approbation, cochez Nécessite une approbation pour exécuter le build.

7. Cliquez sur Créer.

Tester les déclencheurs

Pour tester le déclencheur, vous devez ajouter un nouveau mot dans le fichier d'entrée de test et effectuer l'ajustement correspondant dans le fichier de référence de test. Vous allez vérifier que le pipeline de compilation est déclenché par l'envoi d'un commit dans Cloud Source Repositories et que le workflow de traitement des données s'exécute correctement avec les fichiers de test mis à jour.

1. Dans Cloud Shell, ajoutez un mot test à la fin du fichier de test :

   echo "testword" >>  ~/$SOURCE_CODE_REPO/workflow-dag/support-files/input.txt
   

2. Mettez à jour le fichier de référence des résultats de test, ref.txt, pour qu'il corresponde aux modifications effectuées dans le fichier d'entrée de test :

   echo "testword: 1" >>  ~/$SOURCE_CODE_REPO/workflow-dag/support-files/ref.txt
   

3. Validez les modifications et déployez-les sur Cloud Source Repositories.

   cd ~/$SOURCE_CODE_REPO
   git add .
   git commit -m 'change in test files'
   git push google master
   

4. Dans la console Google Cloud, accédez à la page Historique.

   ACCÉDER À LA PAGE "HISTORIQUE"

5. Pour confirmer qu'une nouvelle compilation de test est déclenchée par l'envoi précédent dans la branche principale, la colonne Ref de la compilation en cours d'exécution indique master.

6. Dans Cloud Shell, obtenez l'URL de votre interface Web Cloud Composer :

   gcloud composer environments describe $COMPOSER_ENV_NAME \
       --location $COMPOSER_REGION --format="get(config.airflowUri)"
   

7. Une fois la compilation terminée, accédez à l'URL de la commande précédente pour vérifier que le DAG test_word_count est en cours d'exécution.

   Attendez la fin de l'exécution du DAG, signalée par la disparition du cercle vert clair de la colonne Exécutions DAG. Cela prend généralement entre trois et cinq minutes.

8. Dans Cloud Shell, téléchargez les fichiers de résultats du test :

   mkdir ~/result-download
   cd ~/result-download
   gsutil cp gs://$RESULT_BUCKET_TEST/output* .
   

9. Vérifiez que le mot que vous venez d'ajouter figure dans l'un des fichiers de résultats :

   grep testword output*
   

   Le résultat ressemble à ce qui suit :

   output-00000-of-00003:testword: 1
   

10. Dans la console Google Cloud, accédez à la page Historique.

    Accéder à la page "Historique"

11. Vérifiez qu'une compilation en production a bien été déclenchée à la fin du test d'intégration et que la compilation est en attente d'approbation.

    

12. Cochez la case à côté de la compilation, cliquez sur Approuver et cliquez sur Approuver dans la boîte de dialogue de confirmation pour exécuter le pipeline de compilation en production.

13. Une fois la compilation terminée, accédez à l'URL de la commande précédente et déclenchez manuellement le DAG prod_word_count pour exécuter le pipeline de production.

    

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer le projet

Attention : La suppression d'un projet aura les effets suivants :
• Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches de ce document, lorsque vous le supprimez, vous supprimez également tout autre travail effectué dans le projet.
• Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.
1. Dans la console Google Cloud, accédez à la page Gérer les ressources.

   Accéder à la page Gérer les ressources

2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer les ressources individuelles

Si vous souhaitez conserver le projet utilisé pour ce tutoriel, procédez comme suit pour supprimer les ressources créées dans ce tutoriel.

1. Pour supprimer le déclencheur Cloud Build, procédez comme suit :

   1. Dans la console Google Cloud, accédez à la page Déclencheurs.

      Accéder à la page "Déclencheurs"

   2. À côté des déclencheurs que vous avez créés, cliquez sur Plus, puis sur Supprimer.

2. Dans Cloud Shell, supprimez l'environnement Cloud Composer :

   gcloud -q composer environments delete $COMPOSER_ENV_NAME \
       --location $COMPOSER_REGION
   

3. Supprimez les buckets Cloud Storage et leurs fichiers :

   gsutil -m rm -r gs://$DATAFLOW_JAR_BUCKET_TEST \
       gs://$INPUT_BUCKET_TEST \
       gs://$REF_BUCKET_TEST \
       gs://$RESULT_BUCKET_TEST \
       gs://$DATAFLOW_STAGING_BUCKET_TEST \
       gs://$DATAFLOW_JAR_BUCKET_PROD \
       gs://$INPUT_BUCKET_PROD \
       gs://$RESULT_BUCKET_PROD \
       gs://$DATAFLOW_STAGING_BUCKET_PROD
   

4. Pour supprimer le sujet Pub/Sub et l'abonnement par défaut, exécutez les commandes suivantes dans Cloud Shell :

   gcloud pubsub topics delete integration-test-complete-topic
   gcloud pubsub subscriptions delete integration-test-complete-topic-sub
   

5. Supprimez le dépôt :

   gcloud -q source repos delete $SOURCE_CODE_REPO
   

6. Supprimez les fichiers et le dossier que vous avez créés :

   rm -rf ~/ci-cd-for-data-processing-workflow
   rm -rf ~/$SOURCE_CODE_REPO
   rm -rf ~/result-download
   

Étapes suivantes

• Découvrez la livraison continue de type GitOps avec Cloud Build.
• Découvrez comment automatiser l'infrastructure avec Cloud Composer.
• Apprenez-en plus sur les modèles courants de cas d'utilisation de Cloud Dataflow.
• Découvrez l'ingénierie des versions.
• Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.