Planifier des exécutions

Ce document vous explique comment effectuer les opérations suivantes dans Dataform :

Le tableau suivant compare les méthodes :

Méthode Objectif Type de déclencheur
Configurations de workflow Exécutions de production standards basées sur le temps dans Dataform. Basé sur l'heure
Workflows et Cloud Scheduler Orchestration sans serveur et légère de Dataform avec d'autres API. Basé sur le temps ou sur des événements
Managed Airflow Pipelines complexes avec des dépendances en dehors de BigQuery. Basé sur le temps ou sur des événements
Déclencheurs de compilation Cloud Build Automatiser les versions immédiatement après un push Git. En fonction des événements

Avant de commencer

Pour planifier des exécutions avec des configurations de workflow ou planifier des exécutions avec des workflows et Cloud Scheduler, procédez comme suit :

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

    Accéder à Dataform

  2. Sélectionnez ou créez un dépôt.

  3. Créez une configuration de version.

Pour planifier des exécutions avec Managed Service pour Apache Airflow, procédez comme suit :

  1. Sélectionnez ou créez un dépôt Dataform.
  2. Accorder à Dataform l'accès à BigQuery
  3. Sélectionnez ou créez un espace de travail Dataform.
  4. Créez au moins une table.
  5. Créez un environnement Managed Airflow 2.

Rôles requis

Pour obtenir les autorisations nécessaires pour effectuer les tâches décrites dans ce document, demandez à votre administrateur de vous accorder les rôles IAM suivants :

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Pour utiliser un compte de service personnalisé lors de la création d'une configuration de workflow, accordez l'accès au compte de service personnalisé.

Pour utiliser les identifiants d'un compte Google lors de la création d'une configuration de workflow, accordez l'accès au compte Google.

Pour activer les exécutions planifiées pour une configuration de workflow, vous devez accorder l'autorisation iam.serviceAccounts.actAs à l'agent de service Dataform par défaut pour le compte de service personnalisé utilisé dans la configuration de workflow. Cette autorisation est disponible dans le rôle Utilisateur du compte de service (roles/iam.serviceAccountUser). Pour en savoir plus, consultez Utiliser le mode d'action strict.

Pour renforcer la sécurité de la planification, consultez Implémenter des autorisations de planification améliorées.

Pour empêcher les utilisateurs de planifier ou d'exécuter des workflows avec des identifiants d'utilisateur final, les administrateurs de l'organisation peuvent créer une contrainte de règle d'administration personnalisée qui refuse de définir end_user_auth_config.

Planifier des exécutions avec des configurations de workflow

Cette section vous explique comment créer une configuration de workflow dans Dataform pour planifier et configurer des exécutions de workflow. Vous pouvez utiliser des configurations de workflow pour exécuter des workflows Dataform de manière planifiée.

À propos des configurations de workflow

Pour planifier l'exécution par Dataform de toutes les actions de workflow ou de certaines d'entre elles dans BigQuery, vous pouvez créer des configurations de workflow. Dans une configuration de workflow, vous sélectionnez une configuration de version de compilation, vous sélectionnez des actions de workflow à exécuter et vous définissez le calendrier d'exécution.

Ensuite, lors d'une exécution planifiée de votre configuration de workflow, Dataform déploie votre sélection d'actions à partir du dernier résultat de compilation de votre configuration de version dans BigQuery. Vous pouvez également déclencher manuellement l'exécution d'une configuration de workflow avec les workflowConfigs de l'API Dataform.

Une configuration de workflow Dataform contient les paramètres d'exécution suivants :

  • ID de la configuration de workflow.
  • Configuration de version.

  • Compte de service.

    Il s'agit du compte de service personnalisé associé à la configuration du workflow. Vous pouvez sélectionner un compte de service personnalisé associé à votre projet Google Cloud ou saisir manuellement un autre compte de service. Par défaut, les configurations de workflow utilisent les mêmes comptes de service que leurs dépôts.

    Les identifiants de compte de service constituent la méthode d'autorisation par défaut pour la création et l'exécution de configurations de workflows planifiés.

  • Identifiants de l'utilisateur du compte Google

    Les identifiants utilisateur du compte Google constituent la méthode d'autorisation par défaut pour la création et l'exécution de configurations de workflows manuelles et non planifiées. Pour en savoir plus, consultez Autoriser votre compte Google.

  • Actions de workflow à exécuter :

    • Toutes les actions.
    • Sélection d'actions.
    • Sélection de tags.

  • La planification et le fuseau horaire de l'exécution.

Créer une configuration de workflow

Pour créer une configuration de workflow Dataform, procédez comme suit :

  1. Dans votre dépôt, accédez à Releases & Scheduling (Versions et planification).
  2. Dans la section Configurations de workflow, cliquez sur Créer.

  3. Dans le volet Créer une configuration de workflow, dans le champ ID de configuration, saisissez un identifiant unique pour la configuration de workflow.

    Les ID ne peuvent contenir que des chiffres, des lettres, des traits d'union et des traits de soulignement.

  4. Dans le menu Configuration de version, sélectionnez une configuration de version de compilation.

  5. Dans la section Authentification, autorisez la configuration du workflow avec les identifiants de votre compte Google ou un compte de service.

    • Pour utiliser les identifiants de votre compte Google, sélectionnez Exécuter avec mes identifiants utilisateur.

      (Facultatif) Dans la section Options d'accès étendu, sélectionnez les services supplémentaires dont votre workflow a besoin :

      • Knowledge Catalog : autorise les mises à jour des métadonnées Google Cloud Knowledge Catalog.
      • Google Drive : permet un accès en lecture seule aux fichiers Google Drive.
      • Bigtable : permet l'accès en lecture seule aux données Google Bigtable.

    • Pour utiliser un compte de service personnalisé, sélectionnez Exécuter avec le compte de service sélectionné, puis sélectionnez le compte de service associé à votre projet Google Cloud auquel vous avez accès. Si vous ne sélectionnez pas de compte de service, la configuration du workflow utilise le compte de service du dépôt.

  6. Facultatif : Dans le champ Fréquence de planification, saisissez la fréquence des exécutions au format unix-cron.

    Pour vérifier que Dataform exécute le dernier résultat de compilation dans la configuration de version correspondante, prévoyez un délai d'au moins une heure entre la création du résultat de compilation et l'exécution planifiée.

  7. Facultatif : Dans le menu Fuseau horaire, sélectionnez le fuseau horaire des exécutions.

    Le fuseau horaire par défaut est "UTC".

  8. Sélectionnez les actions de workflow à exécuter :

    • Pour exécuter l'intégralité du workflow, cliquez sur Toutes les actions.
    • Pour exécuter les actions sélectionnées dans le workflow, cliquez sur Sélection d'actions, puis sélectionnez des actions.
    • Pour exécuter des actions avec les tags sélectionnés, cliquez sur Sélection de tags, puis sélectionnez des tags.
    • Facultatif : Pour exécuter les actions ou les tags sélectionnés et leurs dépendances, sélectionnez l'option Inclure les dépendances.
    • Facultatif : Pour exécuter les actions ou les tags sélectionnés et leurs dépendances, sélectionnez l'option Inclure les dépendances.

    • Facultatif : Pour recréer toutes les tables à partir de zéro, sélectionnez l'option Exécuter avec une actualisation complète.

      Sans cette option, Dataform met à jour les tables incrémentales sans les recréer de zéro.

    • Facultatif : définissez la priorité du job de requête BigQuery avec l'option Exécuter en tant que job interactif avec une priorité élevée (par défaut). Par défaut, BigQuery exécute les requêtes en tant que jobs de requête interactives, qui sont censés démarrer le plus rapidement possible. Si vous décochez cette option, les requêtes sont exécutées en tant que jobs de requête par lot, qui ont une priorité inférieure.

  9. Cliquez sur Créer. Si vous avez sélectionné Exécuter avec mes identifiants utilisateur comme méthode d'authentification, vous devez autoriser votre compte Google.

Par exemple, la configuration de workflow suivante exécute des actions avec le tag hourly toutes les heures dans le fuseau horaire CEST :

  • ID de configuration : production-hourly
  • Configuration de version : -
  • Fréquence : 0 * * * *
  • Fuseau horaire : Central European Summer Time (CEST)
  • Sélection d'actions de workflow : sélection de tags, tag hourly

Autoriser votre compte Google

Pour authentifier la ressource avec les identifiants de votre compte Google, vous devez accorder manuellement l'autorisation aux pipelines BigQuery d'obtenir le jeton d'accès de votre compte Google et d'accéder aux données sources en votre nom. Vous pouvez accorder une approbation manuelle à l'aide de l'interface de la boîte de dialogue OAuth. Si vous sélectionnez des options d'accès étendu, vous devez accorder l'accès à ces services (par exemple, Google Drive ou Knowledge Catalog).

Vous ne devez accorder une autorisation aux pipelines BigQuery qu'une seule fois.

Pour révoquer l'autorisation que vous avez accordée, procédez comme suit :

  1. Accédez à la page de votre compte Google.
  2. Cliquez sur Pipelines BigQuery.
  3. Cliquez sur Supprimer l'accès.

La modification du propriétaire de la configuration du workflow en mettant à jour les identifiants nécessite également une approbation manuelle si le nouveau propriétaire du compte Google n'a jamais créé de configuration de workflow auparavant.

Modifier une configuration de workflow

Pour modifier une configuration de workflow, procédez comme suit :

  1. Dans votre dépôt, accédez à Releases & Scheduling (Versions et planification).
  2. À côté de la configuration de workflow que vous souhaitez modifier, cliquez sur le menu  Plus, puis sur Modifier.
  3. Dans le volet Modifier la configuration du workflow, modifiez les paramètres de configuration du workflow, puis cliquez sur Enregistrer.

Supprimer une configuration de workflow

Pour supprimer une configuration de workflow, procédez comme suit :

  1. Dans votre dépôt, accédez à Releases & Scheduling (Versions et planification).
  2. À côté de la configuration de workflow que vous souhaitez supprimer, cliquez sur le menu  Plus, puis sur Supprimer.
  3. Dans la boîte de dialogue Supprimer la configuration de version, cliquez sur Supprimer.

Planifier des exécutions avec Workflows et Cloud Scheduler

Cette section explique comment planifier l'exécution de workflows Dataform à l'aide de Workflows et de Cloud Scheduler.

À propos des exécutions de workflows planifiées

Vous pouvez définir la fréquence d'exécution de vos workflows Dataform en créant un job Cloud Scheduler qui déclenche un workflow Workflows. Workflows exécute des services dans un workflow d'orchestration que vous définissez.

Workflows exécute votre workflow Dataform en deux étapes. Tout d'abord, il extrait le code de votre dépôt Dataform de votre fournisseur Git et le compile pour obtenir un résultat de compilation. Ensuite, il utilise le résultat de la compilation pour créer un workflow Dataform et l'exécute à la fréquence que vous avez définie.

Créer un workflow d'orchestration planifié

Pour planifier les exécutions de votre workflow Dataform, utilisez Workflows pour créer un workflow d'orchestration et ajoutez un job Cloud Scheduler en tant que déclencheur.

  1. Workflows utilise des comptes de service pour autoriser les workflows à accéder aux ressourcesGoogle Cloud . Créez un compte de service et accordez-lui les autorisations suivantes :

  2. Créez un workflow d'orchestration et utilisez le code source YAML suivant comme définition de workflow :

    main:
    steps:
    - init:
        assign:
        - repository: projects/PROJECT_ID/locations/REPOSITORY_LOCATION/repositories/REPOSITORY_ID
    - createCompilationResult:
        call: http.post
        args:
            url: ${"https://dataform.googleapis.com/v1/" + repository + "/compilationResults"}
            auth:
                type: OAuth2
            body:
                gitCommitish: GIT_COMMITISH
        result: compilationResult
    - createWorkflowInvocation:
        call: http.post
        args:
            url: ${"https://dataform.googleapis.com/v1/" + repository + "/workflowInvocations"}
            auth:
                type: OAuth2
            body:
                compilationResult: ${compilationResult.body.name}
        result: workflowInvocation
    - complete:
        return: ${workflowInvocation.body.name}

    Remplacez les éléments suivants :

    • PROJECT_ID : ID de votre projet Google Cloud .
    • REPOSITORY_LOCATION : emplacement de votre dépôt Dataform.
    • REPOSITORY_ID : nom de votre dépôt Dataform.
    • GIT_COMMITISH : commitish Git (par exemple, une branche, un tag ou un SHA de commit) à partir duquel vous souhaitez exécuter le code Dataform. Pour un dépôt nouvellement créé, remplacez cette valeur par main.

  3. Planifiez le workflow d'orchestration à l'aide de Cloud Scheduler.

Personnaliser la requête de création de résultat de compilation du workflow Dataform

Vous pouvez mettre à jour le workflow d'orchestration existant et définir les paramètres de requête de création de résultat de compilation du workflow Dataform au format YAML. Pour en savoir plus sur les paramètres, consultez la documentation de référence sur la ressource REST projects.locations.repositories.compilationResults.

Par exemple, pour ajouter un paramètre _dev schemaSuffix à toutes les actions lors de la compilation, remplacez le corps de l'étape createCompilationResult par l'extrait de code suivant :

    - createCompilationResult:
        call: http.post
        args:
            url: ${"https://dataform.googleapis.com/v1/" + repository + "/compilationResults"}
            auth:
                type: OAuth2
            body:
                gitCommitish: GIT_COMMITISH
                codeCompilationConfig:
                    schemaSuffix: dev

Vous pouvez également transmettre des paramètres supplémentaires en tant qu'arguments d'exécution dans une requête d'exécution Workflows et accéder à ces arguments à l'aide de variables. Pour en savoir plus, consultez Transmettre des arguments d'exécution dans une requête d'exécution.

Personnaliser la requête d'appel de workflow Dataform

Vous pouvez mettre à jour le workflow d'orchestration existant et définir les paramètres de la requête d'appel du workflow Dataform au format YAML. Pour en savoir plus sur les paramètres de requête d'appel, consultez la documentation de référence sur la ressource REST projects.locations.repositories.workflowInvocations.

Par exemple, pour n'exécuter que les actions associées au tag hourly avec toutes les dépendances transitives incluses, remplacez le corps de createWorkflowInvocation par l'extrait de code suivant :

    - createWorkflowInvocation:
        call: http.post
        args:
            url: ${"https://dataform.googleapis.com/v1/" + repository + "/workflowInvocations"}
            auth:
                type: OAuth2
            body:
                compilationResult: ${compilationResult.body.name}
                invocationConfig:
                    includedTags:
                    - hourly
                    transitiveDependenciesIncluded: true

Vous pouvez également transmettre des paramètres supplémentaires en tant qu'arguments d'exécution dans une requête d'exécution Workflows et accéder à ces arguments à l'aide de variables. Pour en savoir plus, consultez Transmettre des arguments d'exécution dans une requête d'exécution.

Planifier des exécutions avec Managed Airflow

Vous pouvez utiliser Managed Airflow 2 pour planifier des exécutions Dataform. Dataform n'est pas compatible avec Managed Airflow 1.

Pour gérer les planifications des exécutions Dataform avec Managed Airflow 2, vous pouvez utiliser des opérateurs Dataform dans les graphes orientés acycliques (DAG) Airflow. Vous pouvez créer un DAG Airflow qui planifie les appels de workflow Dataform.

Dataform fournit différents opérateurs Airflow. Il s'agit notamment d'opérateurs permettant d'obtenir un résultat de compilation, d'obtenir un appel de workflow et d'annuler un appel de workflow. Pour afficher la liste complète des opérateurs Airflow Dataform disponibles, consultez Opérateurs Google Dataform.

Installez le package PyPI google-cloud-dataform.

Si vous utilisez Managed Airflow 2 versions 2.0.25 et ultérieures, ce package est préinstallé dans votre environnement. Vous n'avez pas besoin de l'installer.

Si vous utilisez des versions antérieures de Managed Airflow 2, installez le package PyPI google-cloud-dataform.

Dans la section "Packages PyPI", spécifiez la version ==0.2.0.

Créer un DAG Airflow qui planifie les appels de workflow Dataform

Pour gérer les exécutions planifiées des workflows Dataform avec Managed Airflow 2, écrivez le DAG à l'aide des opérateurs Airflow Dataform, puis importez-le dans le bucket de votre environnement.

L'exemple de code suivant montre un DAG Airflow qui crée un résultat de compilation Dataform et démarre une invocation de workflow Dataform :

from datetime import datetime

from airflow import models
from airflow.models.baseoperator import chain
from airflow.providers.google.cloud.operators.dataform import (
    DataformCreateCompilationResultOperator,
    DataformCreateWorkflowInvocationOperator,
)

DAG_ID = "dataform"
PROJECT_ID = "PROJECT_ID"
REPOSITORY_ID = "REPOSITORY_ID"
REGION = "REGION"
GIT_COMMITISH = "GIT_COMMITISH"

with models.DAG(
    DAG_ID,
    schedule_interval='@once',  # Override to match your needs
    start_date=datetime(2022, 1, 1),
    catchup=False,  # Override to match your needs
    tags=['dataform'],
) as dag:

    create_compilation_result = DataformCreateCompilationResultOperator(
        task_id="create_compilation_result",
        project_id=PROJECT_ID,
        region=REGION,
        repository_id=REPOSITORY_ID,
        compilation_result={
            "git_commitish": GIT_COMMITISH,
        },
    )
    create_workflow_invocation = DataformCreateWorkflowInvocationOperator(
        task_id='create_workflow_invocation',
        project_id=PROJECT_ID,
        region=REGION,
        repository_id=REPOSITORY_ID,
         workflow_invocation={
            "compilation_result": "{{ task_instance.xcom_pull('create_compilation_result')['name'] }}"
        },
    )


create_compilation_result >> create_workflow_invocation

Remplacez les éléments suivants :

  • PROJECT_ID : ID du projet Dataform Google Cloud .
  • REPOSITORY_ID : nom de votre dépôt Dataform.
  • REGION : région dans laquelle se trouve le dépôt Dataform.
  • COMPILATION_RESULT : nom du résultat de compilation que vous souhaitez utiliser pour cette invocation de workflow.
  • GIT_COMMITISH : commitish Git, tel qu'une branche, un tag ou un SHA de commit, de la version de votre code dans le dépôt Git distant que vous souhaitez compiler.

L'exemple de code suivant montre un DAG Airflow qui effectue les opérations suivantes :

  1. Crée un résultat de compilation Dataform.
  2. Démarre un appel de workflow Dataform asynchrone.
  3. Interroge l'état de votre workflow jusqu'à ce qu'il passe à l'état attendu à l'aide de DataformWorkflowInvocationStateSensor.
from datetime import datetime

from google.cloud.dataform_v1 import WorkflowInvocation

from airflow import models
from airflow.models.baseoperator import chain
from airflow.providers.google.cloud.operators.dataform import (
    DataformCreateCompilationResultOperator,
    DataformCreateWorkflowInvocationOperator,
)
from airflow.providers.google.cloud.sensors.dataform import DataformWorkflowInvocationStateSensor

DAG_ID = "dataform"
PROJECT_ID = "PROJECT_ID"
REPOSITORY_ID = "REPOSITORY_ID"
REGION = "REGION"
GIT_COMMITISH = "GIT_COMMITISH"

with models.DAG(
    DAG_ID,
    schedule_interval='@once',  # Override to match your needs
    start_date=datetime(2022, 1, 1),
    catchup=False,  # Override to match your needs
    tags=['dataform'],
) as dag:

    create_compilation_result = DataformCreateCompilationResultOperator(
        task_id="create_compilation_result",
        project_id=PROJECT_ID,
        region=REGION,
        repository_id=REPOSITORY_ID,
        compilation_result={
            "git_commitish": GIT_COMMITISH,
        },
    )

create_workflow_invocation = DataformCreateWorkflowInvocationOperator(
    task_id='create_workflow_invocation',
    project_id=PROJECT_ID,
    region=REGION,
    repository_id=REPOSITORY_ID,
    asynchronous=True,
    workflow_invocation={
        "compilation_result": COMPILATION_RESULT
    }
)

is_workflow_invocation_done = DataformWorkflowInvocationStateSensor(
    task_id="is_workflow_invocation_done",
    project_id=PROJECT_ID,
    region=REGION,
    repository_id=REPOSITORY_ID,
    workflow_invocation_id=("{{ task_instance.xcom_pull('create_workflow_invocation')['name'].split('/')[-1] }}"),
    expected_statuses={WorkflowInvocation.State.SUCCEEDED},
)


create_compilation_result >> create_workflow_invocation

Remplacez les éléments suivants :

  • PROJECT_ID : ID du projet Dataform Google Cloud .
  • REPOSITORY_ID : nom de votre dépôt Dataform.
  • REGION : région dans laquelle se trouve le dépôt Dataform.
  • COMPILATION_RESULT : nom du résultat de compilation que vous souhaitez utiliser pour cette invocation de workflow.
  • GIT_COMMITISH : commitish Git, tel qu'une branche, un tag ou un SHA de commit, de la version de votre code dans le dépôt Git distant que vous souhaitez compiler.

Ajouter des paramètres de configuration de compilation

Vous pouvez ajouter des paramètres de configuration de compilation supplémentaires à l'objet DAG Airflow create_compilation_result. Pour en savoir plus sur les paramètres disponibles, consultez la documentation de référence de l'API Dataform CodeCompilationConfig.

  • Pour ajouter des paramètres de configuration de compilation à l'objet DAG Airflow create_compilation_result, ajoutez les paramètres sélectionnés au champ code_compilation_config au format suivant :

        create_compilation_result = DataformCreateCompilationResultOperator(
        task_id="create_compilation_result",
        project_id=PROJECT_ID,
        region=REGION,
        repository_id=REPOSITORY_ID,
        compilation_result={
            "git_commitish": GIT_COMMITISH,
            "code_compilation_config": { "PARAMETER": "PARAMETER_VALUE"}
        },
    )

    Remplacez les éléments suivants :

    • PROJECT_ID : ID du projet Dataform Google Cloud .
    • REPOSITORY_ID : nom de votre dépôt Dataform.
    • REGION : région dans laquelle se trouve le dépôt Dataform.
    • GIT_COMMITISH : commitish Git, tel qu'une branche, un tag ou un SHA de commit, de la version de votre code dans le dépôt Git distant que vous souhaitez compiler.
    • PARAMETER : paramètre CodeCompilationConfig sélectionné. Vous pouvez ajouter plusieurs paramètres.
    • PARAMETER_VALUE : valeur du paramètre sélectionné.

L'exemple de code suivant montre le paramètre defaultDatabase ajouté à l'objet DAG Airflow create_compilation_result :

    create_compilation_result = DataformCreateCompilationResultOperator(
        task_id="create_compilation_result",
        project_id=PROJECT_ID,
        region=REGION,
        repository_id=REPOSITORY_ID,
        compilation_result={
            "git_commitish": REMOTE_BRANCH,
            "code_compilation_config": { "default_database": "my-custom-gcp-project"}
        },
    )

Ajouter des paramètres de configuration d'appel de workflow

Vous pouvez ajouter des paramètres de configuration d'appel de workflow supplémentaires à l'objet DAG Airflow create_workflow_invocation. Pour en savoir plus sur les paramètres disponibles, consultez la documentation de référence de l'API Dataform InvocationConfig.

  • Pour ajouter des paramètres de configuration d'appel de workflow à l'objet DAG Airflow create_workflow_invocation, ajoutez les paramètres sélectionnés au champ invocation_config au format suivant :

        create_workflow_invocation = DataformCreateWorkflowInvocationOperator(
        task_id='create_workflow_invocation',
        project_id=PROJECT_ID,
        region=REGION,
        repository_id=REPOSITORY_ID,
        workflow_invocation={
            "compilation_result": "{{ task_instance.xcom_pull('create_compilation_result')['name'] }}",
            "invocation_config": { "PARAMETER": PARAMETER_VALUE }
        },
    )

    Remplacez les éléments suivants :

    • PROJECT_ID : ID du projet Dataform Google Cloud .
    • REPOSITORY_ID : nom de votre dépôt Dataform.
    • REGION : région dans laquelle se trouve le dépôt Dataform.
    • PARAMETER : paramètre InvocationConfig sélectionné. Vous pouvez ajouter plusieurs paramètres.
    • PARAMETER_VALUE : valeur du paramètre sélectionné.

L'exemple de code suivant montre les paramètres includedTags[] et transitiveDependenciesIncluded ajoutés à l'objet DAG Airflow create_workflow_invocation :

    create_workflow_invocation = DataformCreateWorkflowInvocationOperator(
        task_id='create_workflow_invocation',
        project_id=PROJECT_ID,
        region=REGION,
        repository_id=REPOSITORY_ID,
        workflow_invocation={
            "compilation_result": "{{ task_instance.xcom_pull('create_compilation_result')['name'] }}",
            "invocation_config": { "included_tags": ["daily"], "transitive_dependencies_included": true }
        },
    )

Automatiser les exécutions avec des déclencheurs de compilation Cloud Build

Si vous souhaitez aller au-delà des planifications basées sur le temps dans une configuration de version, vous pouvez utiliser un déclencheur de compilation Cloud Build pour créer un pipeline basé sur des événements. Cette approche compile automatiquement votre code chaque fois qu'un nouveau commit est transféré vers une branche Git et déclenche immédiatement l'appel d'un workflow Dataform pour mettre à jour vos données.

Préparer vos ressources

  1. Dans votre projet Google Cloud , activez les API Dataform et Cloud Build :

    Activer l'API Dataform

    Activer l'API Cloud Build

  2. Assurez-vous de disposer des éléments suivants :

Accorder les autorisations Cloud IAM requises

Attribuez le rôle d'administrateur Dataform (roles/dataform.admin) au compte de service personnalisé dans votre dépôt Dataform. Ce rôle fournit un accès complet au dépôt, y compris l'autorisation de créer des résultats de compilation, de mettre à jour les configurations de version et de démarrer de nouvelles appels de workflow. Pour savoir comment attribuer un rôle IAM à un dépôt individuel, consultez Contrôler l'accès à un dépôt individuel.

Attribuez le rôle Utilisateur du compte de service (roles/iam.serviceAccountUser) sur le compte de service personnalisé de la configuration du workflow au compte de service du déclencheur de compilation Cloud Build. Pour en savoir plus sur cette exigence, consultez Utiliser le mode d'emprunt d'identité strict.

Pour que Cloud Build puisse utiliser votre compte de service personnalisé, vous devez autoriser l'agent de service Cloud Build à agir en tant que ce compte. Pour accorder l'autorisation d'emprunt d'identité à l'agent de service Cloud Build, procédez comme suit :

  1. Dans la console Google Cloud , accédez à la page Comptes de service.

    Accéder à la page "Comptes de service"

  2. Sélectionnez votre compte de service personnalisé.

  3. Accédez à l'onglet Comptes principaux avec accès.

  4. Cliquez sur Accorder l'accès.

  5. Dans le champ Nouveaux comptes principaux, saisissez l'adresse e-mail de l'agent de service Cloud Build, qui doit être au format suivant :

    service-PROJECT_NUMBER@gcp-sa-cloudbuild.iam.

    Remplacez PROJECT_NUMBER par l'ID numérique de votre projetGoogle Cloud . Vous trouverez l'ID de votre projet Google Cloud dans le tableau de bord de la consoleGoogle Cloud . Pour en savoir plus, consultez Trouver le nom, le numéro et l'ID du projet.

  6. Dans le menu Sélectionner un rôle, sélectionnez Utilisateur du compte de service.

  7. Cliquez sur Enregistrer.

Créez le fichier de configuration cloudbuild.yaml.

À la racine de votre dépôt Git, créez un fichier cloudbuild.yaml. Utilisez ce fichier pour définir le script en plusieurs étapes suivant afin de créer un résultat de compilation, de mettre à jour la configuration de la version pour définir ce résultat de compilation comme actif et de démarrer un nouvel appel de workflow.

steps:
  - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk:latest'
    entrypoint: 'bash'
    args:
      - '-c'
      - |
        set -e -o pipefail # Exit script on any error

        # 1. Get the access token
        TOKEN=$(gcloud auth print-access-token)

        # 2. Define API endpoints and resource names
        RELEASE_CONFIG_RESOURCE="projects/${_PROJECT_ID}/locations/${_DATAFORM_LOCATION}/repositories/${_DATAFORM_REPO_ID}/releaseConfigs/${_RELEASE_CONFIG_ID}"
        COMPILATION_RESULTS_API="https://dataform.googleapis.com/v1/projects/${_PROJECT_ID}/locations/${_DATAFORM_LOCATION}/repositories/${_DATAFORM_REPO_ID}/compilationResults"

        # 3. Create the new compilation result
        echo "Creating new compilation result from $$RELEASE_CONFIG_RESOURCE..."
        CREATE_PAYLOAD="{\"releaseConfig\": \"$$RELEASE_CONFIG_RESOURCE\"}"
        curl --fail-with-body -X POST \
          -H "Authorization: Bearer $$TOKEN" \
          -H "Content-Type: application/json" \
          -d "$$CREATE_PAYLOAD" \
          "$$COMPILATION_RESULTS_API" | tee /workspace/compilation_response.json

  - name: 'alpine'
    entrypoint: 'bash'
    args:
      - '-c'
      - |
        set -e # Exit script on any error

        # 4. Parse compilation result name
        apk add --no-cache jq
        COMPILATION_NAME=$(jq -r '.name' < /workspace/compilation_response.json)

        echo "Successfully created compilation result: $$COMPILATION_NAME"
        echo $$COMPILATION_NAME > /workspace/compilation_result_name.txt

  - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk:latest'
    entrypoint: 'bash'
    args:
      - '-c'
      - |
        set -e # Exit script on any error
        # 5. Update the releaseConfig to set the new compilation result as 'live'
        COMPILATION_NAME=$(cat /workspace/compilation_result_name.txt)
        echo "Updating release config to set $$COMPILATION_NAME as live..."
        PATCH_PAYLOAD="{\"releaseCompilationResult\": \"$$COMPILATION_NAME\", \"gitCommitish\": \"$BRANCH_NAME\"}"

        RELEASE_CONFIG_RESOURCE="projects/${_PROJECT_ID}/locations/${_DATAFORM_LOCATION}/repositories/${_DATAFORM_REPO_ID}/releaseConfigs/${_RELEASE_CONFIG_ID}"
        RELEASE_CONFIG_PATCH_API="https://dataform.googleapis.com/v1/$${RELEASE_CONFIG_RESOURCE}"
        curl --fail-with-body -X PATCH \
          -H "Authorization: Bearer $(gcloud auth print-access-token)" \
          -H "Content-Type: application/json" \
          -d "$$PATCH_PAYLOAD" \
          "$$RELEASE_CONFIG_PATCH_API?updateMask=releaseCompilationResult"

        echo "Successfully updated release config."

  - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk:latest'
    entrypoint: 'bash'
    args:
      - '-c'
      - |
        set -e # Exit script on any error
        # 6. Launch a workflow config after recompiling the release config
        WORKFLOW_CONFIG_RESOURCE="projects/${_PROJECT_ID}/locations/${_DATAFORM_LOCATION}/repositories/${_DATAFORM_REPO_ID}/workflowConfigs/${_WORKFLOW_CONFIG_ID}"
        CREATE_WORKFLOW_PAYLOAD="{\"workflowConfig\": \"$$WORKFLOW_CONFIG_RESOURCE\"}"

        WORKFLOW_INVOCATIONS_API="https://dataform.googleapis.com/v1/projects/${_PROJECT_ID}/locations/${_DATAFORM_LOCATION}/repositories/${_DATAFORM_REPO_ID}/workflowInvocations"
        curl --fail-with-body -X POST \
          -H "Authorization: Bearer $(gcloud auth print-access-token)" \
          -H "Content-Type: application/json" \
          -d "$$CREATE_WORKFLOW_PAYLOAD" \
          "$$WORKFLOW_INVOCATIONS_API"

        echo "Successfully created a new workflow invocation."

# Define substitution variables that can be set in the trigger
substitutions:
  _DATAFORM_LOCATION: 'us-central1'  # Default, change if needed
  _DATAFORM_REPO_ID: ''              # Required: Set this in the trigger
  _RELEASE_CONFIG_ID: ''             # Required: Set this in the trigger
  _WORKFLOW_CONFIG_ID: ''            # Required: Set this in the trigger
  _PROJECT_ID: ${PROJECT_ID}         # Automatically uses the build's Project ID

options:
  logging: CLOUD_LOGGING_ONLY

Créer le déclencheur de compilation Cloud Build

Pour créer un déclencheur qui exécute votre configuration de compilation lorsque du code est transféré vers votre dépôt, procédez comme suit :

  1. Dans la console Google Cloud , ouvrez la page Déclencheurs de Cloud Build.

    Accéder à la page Déclencheurs

  2. Si vous n'avez pas connecté votre dépôt Git, cliquez sur Connecter un dépôt et suivez les étapes.

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

  4. Saisissez le nom du déclencheur.

  5. Sélectionnez une région pour le déclencheur.

  6. Sélectionnez un événement pour le déclencheur.

  7. Dans la section Source, définissez le dépôt sur votre dépôt Git connecté.

  8. Définissez la branche sur la branche principale de votre dépôt.

  9. Dans la section Configuration, sélectionnez le fichier de configuration Cloud Build, qui peut être un fichier YAML ou JSON.

  10. Définissez l'emplacement du fichier sur /cloudbuild.yaml ou sur le chemin d'accès à votre fichier.

  11. Dans la section Variables de substitution, ajoutez les variables et valeurs suivantes :

    • _DATAFORM_REPO_ID : ID de votre dépôt Dataform
    • _RELEASE_CONFIG_ID : ID de votre configuration de version Dataform
    • _WORKFLOW_CONFIG_ID : ID de votre configuration de workflow Dataform
    • Facultatif : _DATAFORM_LOCATION : région de votre dépôt Dataform, par exemple us-central1

  12. Dans la section Compte de service, sélectionnez votre compte de service personnalisé.

  13. Cliquez sur Créer.

Pour en savoir plus, consultez Créer un déclencheur de compilation.

Tester le déclencheur

  1. Validez et transférez le fichier cloudbuild.yaml vers la branche surveillée par votre déclencheur.

  2. Pour afficher la compilation Cloud Build, ouvrez la page Historique des compilations dans la console Google Cloud .

    Accéder à l'historique de compilation

  3. Si la compilation réussit, accédez à la page Dataform.

    Accéder à Dataform

  4. Sélectionnez votre dépôt.

  5. Cliquez sur Releases & scheduling (Versions et planification), puis sélectionnez votre configuration de version.

  6. Dans la liste Résultats de compilation manuelle/par API, recherchez une nouvelle entrée. La compilation réussie la plus récente doit être marquée comme Résultat de la compilation en ligne pour la configuration de la version.

  7. Cliquez sur Journaux d'exécution de workflow.

  8. Vous devriez voir une nouvelle invocation de workflow lancée à l'aide de la configuration de workflow que vous avez sélectionnée.

Étapes suivantes