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 en production standards et temporelles dans Dataform. En fonction du temps
Workflows et Cloud Scheduler Orchestration légère et sans serveur de Dataform avec d'autres API. Basé sur le temps ou sur des événements
Cloud Composer Pipelines complexes avec des dépendances en dehors de BigQuery. Basé sur le temps ou sur des événements
Déclencheurs 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 Cloud Composer, 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 Cloud Composer 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 de compte Google lorsque vous créez une configuration de workflow (aperçu), 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 du 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 strict "Agir en tant que".

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

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 les 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 des exécutions Dataform de tout ou partie des actions de workflow dans BigQuery, vous pouvez créer des configurations de workflow. Dans une configuration de workflow, vous sélectionnez une configuration de compilation, des actions de workflow à exécuter et la planification d'exécution.

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

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

  • ID de la configuration du workflow.
  • Configuration de la 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 sont la méthode d'autorisation par défaut pour la création et l'exécution de configurations de workflows planifiés.

  • Identifiants de compte Google (aperçu)

    Les identifiants de compte Google sont la méthode d'autorisation par défaut pour la création et l'exécution manuelles de configurations de workflow 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.

  • Programmation d'exécution et fuseau horaire.

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 Create workflow configuration (Créer une configuration de workflow), saisissez un ID unique pour la configuration de workflow dans le champ Configuration ID (ID de configuration).

    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 vos identifiants de compte Google ou un compte de service.

    • Pour utiliser les identifiants utilisateur de votre compte Google (Aperçu), sélectionnez Exécuter avec mes identifiants utilisateur.
    • 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 d'exécution 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 les actions.
    • Pour exécuter des actions avec les tags sélectionnés, cliquez sur Sélection de tags, puis sélectionnez les tags.
    • Facultatif : Pour exécuter les actions ou les balises sélectionnées et leurs dépendances, sélectionnez l'option Inclure les dépendances.
    • Facultatif : Pour exécuter les actions ou les balises sélectionnées et leurs dépendances, sélectionnez l'option Inclure les dépendances.

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

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

    • Facultatif : Définissez la priorité de la tâche 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 tâches de requête interactives, qui sont censées commencer à s'exécuter le plus rapidement possible. Si vous décochez cette option, les requêtes seront 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 (Aperçu).

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 pour obtenir le jeton d'accès de votre compte Google et accéder aux données source en votre nom. Vous pouvez accorder une approbation manuelle à l'aide de l'interface de la boîte de dialogue OAuth.

Vous n'avez besoin d'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 vous explique comment planifier l'exécution de workflows Dataform à l'aide de Workflows et de Cloud Scheduler.

À propos des exécutions de workflow 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. Il utilise ensuite 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 une tâche Cloud Scheduler comme déclencheur.

  1. Workflows utilise des comptes de service pour permettre aux workflows d'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/v1beta1/" + repository + "/compilationResults"}
            auth:
                type: OAuth2
            body:
                gitCommitish: GIT_COMMITISH
        result: compilationResult
    - createWorkflowInvocation:
        call: http.post
        args:
            url: ${"https://dataform.googleapis.com/v1beta1/" + 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 : branche Git à partir de laquelle vous souhaitez exécuter le code Dataform. Pour un dépôt nouvellement créé, remplacez cette ressource par main.

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

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

Vous pouvez mettre à jour le workflow d'orchestration existant et définir les paramètres de la requête de création du 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/v1beta1/" + 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 de workflows et y accéder à l'aide de variables. Pour en savoir plus, consultez Transmettre des arguments d'environnement d'exécution dans une requête d'exécution.

Personnaliser la demande 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 la requête d'invocation, consultez la documentation de référence sur la ressource REST projects.locations.repositories.workflowInvocations.

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

    - createWorkflowInvocation:
        call: http.post
        args:
            url: ${"https://dataform.googleapis.com/v1beta1/" + 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 de workflows et y accéder à l'aide de variables. Pour en savoir plus, consultez Transmettre des arguments d'environnement d'exécution dans une requête d'exécution.

Planifier des exécutions avec Cloud Composer

Vous pouvez utiliser Cloud Composer 2 pour planifier les exécutions Dataform. Dataform n'est pas compatible avec Cloud Composer 1.

Pour gérer les planifications des exécutions Dataform avec Cloud Composer 2, vous pouvez utiliser les 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, entre autres, 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 Dataform Airflow disponibles, consultez Opérateurs Google Dataform.

Installer le package PyPi google-cloud-dataform

Si vous utilisez Cloud Composer 2 version 2.0.25 ou ultérieure, ce package est préinstallé dans votre environnement. Vous n'avez pas besoin de l'installer.

Si vous utilisez des versions antérieures de Cloud Composer 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 de workflows Dataform avec Cloud Composer 2, écrivez le DAG à l'aide des opérateurs Dataform Airflow, 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 lance 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 de votre projet Google Cloud Dataform.
  • 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 la compilation que vous souhaitez utiliser pour cette invocation de workflow.
  • GIT_COMMITISH : commit Git dans le dépôt Git distant de la version de votre code que vous souhaitez utiliser (par exemple, une branche ou un SHA Git).

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 atteigne l'état attendu à l'aide de DataformWorkflowInvocationStateSensor.
from datetime import datetime

from google.cloud.dataform_v1beta1 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 de votre 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 la compilation que vous souhaitez utiliser pour cette invocation de workflow.
  • GIT_COMMITISH : commit Git dans le dépôt Git distant de la version de votre code que vous souhaitez utiliser (par exemple, une branche ou un SHA Git).
  • COMPILATION_RESULT : nom du résultat de la compilation que vous souhaitez utiliser pour cette invocation de workflow.

Ajouter des paramètres de configuration de la compilation

Vous pouvez ajouter d'autres paramètres de configuration de compilation à 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 la 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 de votre projet Google Cloud Dataform.
    • REPOSITORY_ID : nom de votre dépôt Dataform.
    • REGION : région dans laquelle se trouve le dépôt Dataform.
    • GIT_COMMITISH : commit Git dans le dépôt Git distant de la version de votre code que vous souhaitez utiliser (par exemple, une branche ou un SHA Git).
    • 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 de votre projet Google Cloud Dataform.
    • 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 Cloud Build

Si vous souhaitez aller au-delà des plannings basés sur le temps dans une configuration de version, vous pouvez utiliser un déclencheur 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 envoyé vers une branche Git et déclenche immédiatement un appel de 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 Administrateur Dataform (roles/dataform.admin) au compte de service personnalisé dans votre dépôt Dataform. Ce rôle offre un accès complet au dépôt, y compris l'autorisation de créer des résultats de compilation, de mettre à jour des configurations de version et de démarrer de nouvelles invocations 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 Cloud Build. Pour en savoir plus sur cette exigence, consultez Utiliser le mode strict "Agis comme".

Pour que Cloud Build utilise votre compte de service personnalisé, vous devez accorder à l'agent de service Cloud Build l'autorisation d'agir en tant que ce compte. Pour accorder l'autorisation d'usurpation 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.gserviceaccount.com

    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éer 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 : création d'un résultat de compilation, mise à jour de la configuration de la version pour définir ce résultat de compilation comme actif et démarrage d'une nouvelle invocation 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 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 la procédure.

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

  4. Saisissez un nom pour le 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 associé.

  8. Définissez 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 configuration de votre version Dataform
    • _WORKFLOW_CONFIG_ID : ID de configuration de votre 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 que votre déclencheur surveille.

  2. Pour afficher la compilation Cloud Build, ouvrez la page Historique de compilation 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 Versions et programmation, puis sélectionnez la configuration de votre version.

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

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

  8. Une nouvelle invocation de workflow devrait être lancée à l'aide de la configuration de workflow que vous avez sélectionnée.

Étape suivante