Pianificare le esecuzioni

Questo documento mostra come eseguire le seguenti operazioni in Dataform:

La seguente tabella mette a confronto i metodi:

Metodo Obiettivo Tipo di trigger
Configurazioni dei workflow Esecuzioni di produzione standard basate sul tempo all'interno di Dataform. Basato sull'ora
Workflows e Cloud Scheduler Orchestrazione serverless e leggera di Dataform insieme ad altre API. Basato sul tempo o sugli eventi
Managed Airflow Pipeline complesse con dipendenze esterne a BigQuery. Basato sul tempo o sugli eventi
Trigger di Cloud Build Automatizzare le release immediatamente dopo un push Git. Basata su eventi

Prima di iniziare

Per pianificare le esecuzioni con le configurazioni dei workflow o pianificare le esecuzioni con i workflow e Cloud Scheduler, segui questi passaggi:

  1. Nella console Google Cloud , vai alla pagina Dataform.

    Vai a Dataform

  2. Seleziona o crea un repository.

  3. Crea una configurazione della release.

Per pianificare le esecuzioni con Managed Service for Apache Airflow, segui questi passaggi:

  1. Seleziona o crea un repository Dataform.
  2. Concedi a Dataform l'accesso a BigQuery.
  3. Seleziona o crea un workspace Dataform.
  4. Crea almeno una tabella.
  5. Crea un ambiente Managed Airflow 2.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per completare le attività descritte in questo documento, chiedi all'amministratore di concederti i seguenti ruoli IAM:

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Per utilizzare un account di servizio personalizzato durante la creazione di una configurazione del workflow, concedi l'accesso al service account personalizzato.

Per utilizzare le credenziali utente di un Account Google durante la creazione di una configurazione del workflow, concedi l'accesso all'Account Google.

Per abilitare le esecuzioni pianificate per una configurazione del workflow, devi concedere l'autorizzazione iam.serviceAccounts.actAs all'agente di servizio Dataform predefinito per il account di servizio personalizzato utilizzato nella configurazione del workflow. Questa autorizzazione è disponibile nel ruolo Service Account User (roles/iam.serviceAccountUser). Per ulteriori informazioni, consulta Utilizza la modalità act-as rigorosa.

Per migliorare la sicurezza della pianificazione, consulta Implementa autorizzazioni di pianificazione avanzate.

Per impedire agli utenti di pianificare o eseguire workflow con le credenziali dell'utente finale, gli amministratori dell'organizzazione possono creare un vincolo della policy dell'organizzazione personalizzato che nega l'impostazione di end_user_auth_config.

Pianifica le esecuzioni con le configurazioni del workflow

Questa sezione mostra come creare una configurazione del workflow in Dataform per pianificare e configurare le esecuzioni del workflow. Puoi utilizzare le configurazioni del workflow per eseguire i workflow di Dataform in base a una pianificazione.

Informazioni sulle configurazioni dei workflow

Per pianificare le esecuzioni Dataform di tutte o alcune azioni del workflow in BigQuery, puoi creare configurazioni del workflow. In una configurazione del workflow, selezioni una configurazione della release di compilazione, selezioni le azioni del workflow da eseguire e imposti la pianificazione dell'esecuzione.

Poi, durante un'esecuzione pianificata della configurazione del workflow, Dataform esegue il deployment in BigQuery della selezione di azioni dall'ultimo risultato della compilazione nella configurazione della release. Puoi anche attivare manualmente l'esecuzione di una configurazione del workflow con i workflowConfigs dell'API Dataform.

Una configurazione del workflow di Dataform contiene le seguenti impostazioni di esecuzione:

  • ID della configurazione del workflow.
  • Configurazione della release.

  • Service account.

    Questo è il account di servizio personalizzato associato alla configurazione del workflow. Puoi selezionare un account di servizio personalizzato associato al tuo progetto Google Cloud oppure inserire manualmente un account di servizio diverso. Per impostazione predefinita, le configurazioni dei workflow utilizzano gli stessi service account dei loro repository.

    Le credenziali del service account sono il metodo di autorizzazione predefinito per la creazione e l'esecuzione della configurazione del workflow pianificato.

  • Credenziali utente dell'Account Google

    Le credenziali utente dell'Account Google sono il metodo di autorizzazione predefinito per la creazione e l'esecuzione manuale e non pianificata della configurazione del workflow. Per ulteriori informazioni, vedi Autorizza l'Account Google.

  • Azioni del workflow da eseguire:

    • Tutte le azioni.
    • Selezione di azioni.
    • Selezione di tag.

  • Pianificazione delle esecuzioni e fuso orario.

Crea una configurazione di flusso di lavoro

Per creare una configurazione del workflow di Dataform, segui questi passaggi:

  1. Nel tuo repository, vai a Release e programmazione.
  2. Nella sezione Configurazioni del workflow, fai clic su Crea.

  3. Nel riquadro Crea configurazione del workflow, inserisci un ID univoco per la configurazione del workflow nel campo ID configurazione.

    Gli ID possono includere solo numeri, lettere, trattini e trattini bassi.

  4. Nel menu Configurazione della release, seleziona una configurazione della release di compilazione.

  5. Nella sezione Autenticazione, autorizza la configurazione del workflow con le credenziali utente del tuo Account Google o con un service account.

    • Per utilizzare le credenziali utente del tuo Account Google, seleziona Esegui con le mie credenziali utente.

      (Facoltativo) Nella sezione Opzioni di accesso esteso, seleziona i servizi aggiuntivi richiesti dal tuo workflow:

      • Knowledge Catalog: consente gli aggiornamenti dei metadati di Google Cloud Knowledge Catalog.
      • Google Drive: consente l'accesso di sola lettura ai file di Google Drive.
      • Bigtable: consente l'accesso di sola lettura ai dati di Google Bigtable.

    • Per utilizzare un account di servizio personalizzato, seleziona Esegui con il service account selezionato, quindi seleziona il service account associato al tuo progetto Google Cloud a cui hai accesso. Se non selezioni un account di servizio, la configurazione del workflow utilizza il account di servizio del repository.

  6. (Facoltativo) Nel campo Frequenza di pianificazione, inserisci la frequenza delle esecuzioni nel formato unix-cron.

    Per verificare che Dataform esegua l'ultimo risultato della compilazione nella configurazione della release corrispondente, mantieni un intervallo minimo di un'ora tra il momento della creazione del risultato della compilazione e il momento dell'esecuzione pianificata.

  7. (Facoltativo) Nel menu Fuso orario, seleziona il fuso orario per le esecuzioni.

    Il fuso orario predefinito è UTC.

  8. Seleziona le azioni del workflow da eseguire:

    • Per eseguire l'intero workflow, fai clic su Tutte le azioni.
    • Per eseguire le azioni selezionate nel workflow, fai clic su Selezione delle azioni, quindi seleziona le azioni.
    • Per eseguire azioni con i tag selezionati, fai clic su Selezione dei tag, quindi seleziona i tag.
    • (Facoltativo) Per eseguire le azioni o i tag selezionati e le relative dipendenze, seleziona l'opzione Includi dipendenze.
    • (Facoltativo) Per eseguire le azioni o i tag selezionati e i relativi elementi dipendenti, seleziona l'opzione Includi dipendenti.

    • (Facoltativo) Per ricreare tutte le tabelle da zero, seleziona l'opzione Esegui con aggiornamento completo.

      Senza questa opzione, Dataform aggiorna le tabelle incrementali senza ricrearle da zero.

    • (Facoltativo) Imposta la priorità del job di query BigQuery con l'opzione Esegui come job interattivo con priorità alta (impostazione predefinita). Per impostazione predefinita, BigQuery esegue le query come job di query interattive, che devono essere eseguiti il più rapidamente possibile. Se deselezioni questa opzione, le query vengono eseguite come job di query batch, che hanno una priorità inferiore.

  9. Fai clic su Crea. Se hai selezionato Esegui con le mie credenziali utente come metodo di autenticazione, devi autorizzare il tuo Account Google.

Ad esempio, la seguente configurazione del workflow esegue azioni con il tag hourly ogni ora nel fuso orario CEST:

  • ID configurazione: production-hourly
  • Configurazione della release: -
  • Frequenza: 0 * * * *
  • Fuso orario: Central European Summer Time (CEST)
  • Selezione delle azioni del workflow: selezione dei tag, tag hourly

Autorizzare l'Account Google

Per autenticare la risorsa con le credenziali utente del tuo Account Google, devi concedere manualmente l'autorizzazione alle pipeline BigQuery per ottenere il token di accesso per il tuo Account Google e accedere ai dati di origine per tuo conto. Puoi concedere l'approvazione manuale con l'interfaccia della finestra di dialogo OAuth. Se selezioni una delle opzioni di accesso esteso, devi concedere l'accesso a questi servizi, ad esempio Google Drive o Knowledge Catalog.

Devi concedere l'autorizzazione alle pipeline BigQuery una sola volta.

Per revocare l'autorizzazione che hai concesso, segui questi passaggi:

  1. Vai alla pagina del tuo Account Google.
  2. Fai clic su Pipeline BigQuery.
  3. Fai clic su Rimuovi accesso.

Anche la modifica del proprietario della configurazione del workflow tramite l'aggiornamento delle credenziali richiede l'approvazione manuale se il nuovo proprietario dell'Account Google non ha mai creato una configurazione del workflow in precedenza.

Modifica una configurazione del workflow

Per modificare la configurazione di un workflow, segui questi passaggi:

  1. Nel tuo repository, vai a Release e programmazione.
  2. Accanto alla configurazione del workflow che vuoi modificare, fai clic sul menu Altro e poi su Modifica.
  3. Nel riquadro Modifica configurazione del workflow, modifica le impostazioni di configurazione del workflow e poi fai clic su Salva.

Elimina una configurazione del workflow

Per eliminare una configurazione del workflow:

  1. Nel tuo repository, vai a Release e programmazione.
  2. Accanto alla configurazione del workflow che vuoi eliminare, fai clic sul menu Altro e poi su Elimina.
  3. Nella finestra di dialogo Elimina configurazione della release, fai clic su Elimina.

Pianifica le esecuzioni con Workflows e Cloud Scheduler

Questa sezione mostra come pianificare le esecuzioni dei flussi di lavoro Dataform utilizzando Workflows e Cloud Scheduler.

Informazioni sulle esecuzioni dei workflow pianificati

Puoi impostare la frequenza delle esecuzioni del workflow di Dataform creando un job Cloud Scheduler che attiva un workflow di Workflows. Workflows esegue i servizi in un workflow di orchestrazione definito da te.

Workflows esegue il workflow di Dataform in un processo in due passaggi. Innanzitutto, esegue il pull del codice del repository Dataform dal provider Git e lo compila in un risultato di compilazione. Poi, utilizza il risultato della compilazione per creare un workflow Dataform ed eseguirlo con la frequenza impostata.

Crea un workflow di orchestrazione pianificato

Per pianificare le esecuzioni del workflow Dataform, utilizza Workflows per creare un workflow di orchestrazione e aggiungi un job Cloud Scheduler come trigger.

  1. Workflows utilizza i service account per concedere ai workflow l'accesso alle risorseGoogle Cloud . Crea un service account e concedigli le seguenti autorizzazioni:

  2. Crea un workflow di orchestrazione e utilizza il seguente codice sorgente YAML come definizione del 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}

    Sostituisci quanto segue:

    • PROJECT_ID: l'ID del tuo progetto Google Cloud .
    • REPOSITORY_LOCATION: la località del repository Dataform.
    • REPOSITORY_ID: il nome del repository Dataform.
    • GIT_COMMITISH: il commitish Git, ad esempio un branch, un tag o uno SHA di commit, da cui vuoi eseguire il codice Dataform. Per un repository appena creato, sostituisci questo valore con main.

  3. Pianifica il workflow di orchestrazione utilizzando Cloud Scheduler.

Personalizza la richiesta di creazione del risultato della compilazione del workflow di Dataform

Puoi aggiornare il workflow di orchestrazione esistente e definire le impostazioni della richiesta di creazione del risultato della compilazione del workflow di Dataform in formato YAML. Per saperne di più sulle impostazioni, consulta il riferimento alla risorsa REST projects.locations.repositories.compilationResults.

Ad esempio, per aggiungere un'impostazione _dev schemaSuffix a tutte le azioni durante la compilazione, sostituisci il corpo del passaggio createCompilationResult con il seguente snippet di codice:

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

Puoi anche passare impostazioni aggiuntive come argomenti di runtime in una richiesta di esecuzione di Workflows e accedere a questi argomenti utilizzando le variabili. Per saperne di più, consulta Passa gli argomenti di runtime in una richiesta di esecuzione.

Personalizza la richiesta di chiamata del workflow Dataform

Puoi aggiornare il workflow di orchestrazione esistente e definire le impostazioni della richiesta di chiamata del workflow di Dataform in formato YAML. Per saperne di più sulle impostazioni della richiesta di chiamata, consulta il riferimento alla risorsa REST projects.locations.repositories.workflowInvocations.

Ad esempio, per eseguire solo le azioni con il tag hourly con tutte le dipendenze transitive incluse, sostituisci il corpo createWorkflowInvocation con il seguente snippet di codice:

    - 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

Puoi anche passare impostazioni aggiuntive come argomenti di runtime in una richiesta di esecuzione di Workflows e accedere a questi argomenti utilizzando le variabili. Per saperne di più, consulta Passa gli argomenti di runtime in una richiesta di esecuzione.

Pianifica le esecuzioni con Managed Airflow

Puoi utilizzare Managed Airflow 2 per pianificare le esecuzioni di Dataform. Dataform non supporta Managed Airflow 1.

Per gestire le pianificazioni per le esecuzioni di Dataform con Managed Airflow 2, puoi utilizzare gli operatori Dataform nei grafi diretti aciclici (DAG) di Airflow. Puoi creare un DAG Airflow che pianifica le chiamate dei workflow Dataform.

Dataform fornisce vari operatori Airflow. Questi includono operatori per ottenere un risultato di compilazione, ottenere un'invocazione del workflow e annullare un'invocazione del workflow. Per visualizzare l'elenco completo degli operatori Airflow di Dataform disponibili, consulta Operatori Google Dataform.

Installa il pacchetto PyPI google-cloud-dataform

Se utilizzi Managed Airflow 2 versioni 2.0.25 e successive, questo pacchetto è preinstallato nel tuo ambiente. Non è necessario installarlo.

Se utilizzi versioni precedenti di Managed Airflow 2, installa il pacchetto PyPI google-cloud-dataform.

Nella sezione Pacchetti PyPI, specifica la versione ==0.2.0.

Crea un DAG Airflow che pianifica le chiamate del workflow di Dataform

Per gestire le esecuzioni pianificate dei workflow di Dataform con Managed Airflow 2, scrivi il DAG utilizzando gli operatori Airflow di Dataform, quindi caricalo nel bucket del tuo ambiente.

Il seguente esempio di codice mostra un DAG Airflow che crea un risultato di compilazione Dataform e avvia una chiamata del 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

Sostituisci quanto segue:

  • PROJECT_ID: l'ID progetto Dataform Google Cloud .
  • REPOSITORY_ID: il nome del repository Dataform.
  • REGION: la regione in cui si trova il repository Dataform.
  • COMPILATION_RESULT: il nome del risultato della compilazione che vuoi utilizzare per questa chiamata del workflow.
  • GIT_COMMITISH: il commitish Git, ad esempio un branch, un tag o un SHA di commit, della versione del codice nel repository Git remoto che vuoi compilare.

Il seguente esempio di codice mostra un DAG Airflow che esegue quanto segue:

  1. Crea un risultato della compilazione di Dataform.
  2. Avvia una chiamata asincrona del workflow Dataform.
  3. Esegue il polling dello stato del workflow finché non entra nello stato previsto utilizzando 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

Sostituisci quanto segue:

  • PROJECT_ID: l'ID progetto Dataform Google Cloud .
  • REPOSITORY_ID: il nome del repository Dataform.
  • REGION: la regione in cui si trova il repository Dataform.
  • COMPILATION_RESULT: il nome del risultato della compilazione che vuoi utilizzare per questa chiamata del workflow.
  • GIT_COMMITISH: il commitish Git, ad esempio un branch, un tag o un SHA di commit, della versione del codice nel repository Git remoto che vuoi compilare.

Aggiungi parametri di configurazione della compilazione

Puoi aggiungere altri parametri di configurazione della compilazione all'oggetto DAG Airflow create_compilation_result. Per saperne di più sui parametri disponibili, consulta il riferimento API Dataform CodeCompilationConfig.

  • Per aggiungere parametri di configurazione della compilazione all'oggetto DAG Airflow create_compilation_result, aggiungi i parametri selezionati al campo code_compilation_config nel seguente formato:

        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"}
        },
    )

    Sostituisci quanto segue:

    • PROJECT_ID: l'ID progetto Dataform Google Cloud .
    • REPOSITORY_ID: il nome del repository Dataform.
    • REGION: la regione in cui si trova il repository Dataform.
    • GIT_COMMITISH: il commitish Git, ad esempio un branch, un tag o uno SHA di commit, della versione del codice nel repository Git remoto che vuoi compilare.
    • PARAMETER: il parametro CodeCompilationConfig selezionato. Puoi aggiungere più parametri.
    • PARAMETER_VALUE: il valore del parametro selezionato.

Il seguente esempio di codice mostra il parametro defaultDatabase aggiunto all'oggetto 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"}
        },
    )

Aggiungi i parametri di configurazione della chiamata del workflow

Puoi aggiungere altri parametri di configurazione della chiamata del workflow all'oggetto DAG Airflow create_workflow_invocation. Per saperne di più sui parametri disponibili, consulta il riferimento API Dataform InvocationConfig.

  • Per aggiungere i parametri di configurazione della chiamata del workflow all'oggetto DAG Airflow create_workflow_invocation, aggiungi i parametri selezionati al campo invocation_config nel seguente formato:

        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 }
        },
    )

    Sostituisci quanto segue:

    • PROJECT_ID: l'ID progetto Dataform Google Cloud .
    • REPOSITORY_ID: il nome del repository Dataform.
    • REGION: la regione in cui si trova il repository Dataform.
    • PARAMETER: il parametro InvocationConfig selezionato. Puoi aggiungere più parametri.
    • PARAMETER_VALUE: il valore del parametro selezionato.

Il seguente esempio di codice mostra i parametri includedTags[] e transitiveDependenciesIncluded aggiunti all'oggetto 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 }
        },
    )

Automatizza le esecuzioni con i trigger di build di Cloud Build

Se vuoi andare oltre le pianificazioni basate sul tempo in una configurazione di release, puoi utilizzare un trigger di Cloud Build per creare una pipeline basata su eventi. Questo approccio compila automaticamente il codice ogni volta che viene eseguito il push di un nuovo commit in un branch Git e attiva immediatamente una chiamata del workflow Dataform per aggiornare i dati.

Prepara le risorse

  1. Nel tuo progetto Google Cloud , abilita le API Dataform e Cloud Build:

    Abilita l'API Dataform

    Abilita l'API Cloud Build

  2. Assicurati di disporre di quanto segue:

Concedi le autorizzazioni IAM richieste

Concedi il ruolo Dataform Admin (roles/dataform.admin) al account di servizio personalizzato nel repository Dataform. Questo ruolo fornisce l'accesso completo al repository, inclusa l'autorizzazione per creare risultati di compilazione, aggiornare le configurazioni delle release e avviare nuove chiamate del workflow. Per informazioni dettagliate su come concedere un ruolo IAM a un singolo repository, consulta Controlla l'accesso a un singolo repository.

Concedi il ruolo Service Account User (roles/iam.serviceAccountUser) sul account di servizio personalizzato della configurazione del workflow al account di servizio del trigger Cloud Build. Per ulteriori informazioni su questo requisito, consulta Utilizza la modalità actAs rigorosa.

Affinché Cloud Build possa utilizzare il tuo account di servizio personalizzato, devi concedere all'agente di servizio Cloud Build l'autorizzazione per agire come quell'account. Per concedere l'autorizzazione di impersonificazione all'agente di servizio Cloud Build, segui questi passaggi:

  1. Nella console Google Cloud , vai alla pagina Service account.

    Vai a Service account

  2. Seleziona il tuo account di servizio personalizzato.

  3. Vai alla scheda Entità con accesso.

  4. Fai clic su Concedi l'accesso.

  5. Nel campo Nuove entità, inserisci l'indirizzo email dell'agente di servizio Cloud Build, che deve essere nel seguente formato:

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

    Sostituisci PROJECT_NUMBER con l'ID numerico del tuo progettoGoogle Cloud . Puoi trovare l'ID progetto Google Cloud nella dashboard della consoleGoogle Cloud . Per saperne di più, consulta Trova il nome, il numero e l'ID del progetto.

  6. Nel menu Seleziona un ruolo, seleziona Service Account User.

  7. Fai clic su Salva.

Crea il file di configurazione cloudbuild.yaml

Nella directory root del repository Git, crea un file cloudbuild.yaml. Utilizza questo file per definire il seguente script in più passaggi per creare un risultato della compilazione, aggiornare la configurazione della release per impostare questo risultato della compilazione come attivo e avviare una nuova chiamata del 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

Crea il trigger di Cloud Build

Per creare un trigger che esegua la configurazione di compilazione quando viene eseguito il push del codice nel tuo repository, segui questi passaggi:

  1. Nella console Google Cloud , apri la pagina Trigger di Cloud Build.

    Vai ai trigger

  2. Se non hai connesso il repository Git, fai clic su Connetti repository e segui i passaggi.

  3. Fai clic su Crea trigger.

  4. Inserisci un nome per l'attivatore.

  5. Seleziona una regione per il trigger.

  6. Seleziona un evento per l'attivatore.

  7. Nella sezione Origine, imposta il repository sul repository Git connesso.

  8. Imposta il branch sul branch principale del repository.

  9. Nella sezione Configurazione, seleziona il file di configurazione di Cloud Build, che può essere un file YAML o JSON.

  10. Imposta la posizione del file su /cloudbuild.yaml o sul percorso del file.

  11. Nella sezione Variabili di sostituzione, aggiungi le seguenti variabili e i seguenti valori:

    • _DATAFORM_REPO_ID: l'ID del tuo repository Dataform
    • _RELEASE_CONFIG_ID: l'ID della configurazione della release di Dataform
    • _WORKFLOW_CONFIG_ID: l'ID della configurazione del workflow Dataform
    • (Facoltativo) _DATAFORM_LOCATION: la regione del repository Dataform, ad esempio us-central1

  12. Nella sezione Service account, seleziona il tuo account di servizio personalizzato.

  13. Fai clic su Crea.

Per saperne di più, consulta Crea un trigger di build.

Testa l'attivatore

  1. Esegui il commit e il push del file cloudbuild.yaml nel branch monitorato dal trigger.

  2. Per visualizzare la build di Cloud Build, apri la pagina Cronologia build nella console Google Cloud .

    Vai alla cronologia delle build

  3. Se la build va a buon fine, vai alla pagina Dataform.

    Vai a Dataform

  4. Seleziona il tuo repository.

  5. Fai clic su Release e programmazione e seleziona la configurazione della release.

  6. Nell'elenco Risultati di compilazione manuale/API, cerca una nuova voce. La compilazione riuscita più recente deve essere contrassegnata come Risultato della compilazione attiva per la configurazione della release.

  7. Fai clic su Log di esecuzione del flusso di lavoro.

  8. Dovresti vedere una nuova esecuzione del workflow avviata utilizzando la configurazione del workflow selezionata.

Passaggi successivi