Pianificare le esecuzioni

Questo documento mostra come eseguire le seguenti operazioni in Dataform:

La seguente tabella confronta i metodi:

Metodo Obiettivo Tipo di trigger
Configurazioni dei workflow Esecuzioni di produzione standard basate sul tempo in Dataform. Basato sul tempo
Workflows e Cloud Scheduler Orchestrazione leggera e serverless di Dataform insieme ad altre API. Basati sul tempo o su eventi
Cloud Composer Pipeline complesse con dipendenze esterne a BigQuery. Basati sul tempo o su eventi
Trigger di Cloud Build Automatizzare le release subito dopo un push Git. Basata su eventi

Prima di iniziare

Per pianificare le esecuzioni con le configurazioni del flusso di lavoro o pianificare le esecuzioni con i workflow e Cloud Scheduler, procedi nel seguente modo:

  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 Cloud Composer:

  1. Seleziona o crea un repository Dataform.
  2. Concedere a Dataform l'accesso a BigQuery.
  3. Seleziona o crea un workspace Dataform.
  4. Crea almeno una tabella.
  5. Crea un ambiente Cloud Composer 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 service account personalizzato durante la creazione di una configurazione del workflow, concedi l'accesso al service account personalizzato.

Per utilizzare le credenziali utente dell'Account Google durante la creazione di una configurazione del flusso di lavoro (anteprima), concedi l'accesso all'Account Google.

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

Per migliorare la sicurezza della pianificazione, vedi Implementare autorizzazioni di pianificazione avanzate.

Pianificare 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 Dataform in base a una pianificazione.

Informazioni sulle configurazioni dei workflow

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

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

Una configurazione del flusso di lavoro Dataform contiene le seguenti impostazioni di esecuzione:

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

  • Service account.

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

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

  • Credenziali utente dell'Account Google (anteprima)

    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 maggiori informazioni, vedi Autorizzare l'Account Google.

  • Azioni del workflow da eseguire:

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

  • Pianificazione dell'esecuzione e fuso orario.

Crea una configurazione di flusso di lavoro

Per creare una configurazione del flusso di lavoro Dataform:

  1. Nel repository, vai a Releases & Scheduling (Uscite e programmazione).
  2. Nella sezione Configurazioni dei flussi di lavoro, fai clic su Crea.

  3. Nel riquadro Crea configurazione del flusso di lavoro, inserisci un ID univoco per la configurazione del flusso di lavoro 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 flusso di lavoro con le credenziali utente del tuo Account Google o un account di servizio.

    • Per utilizzare le credenziali utente del tuo Account Google (Anteprima), seleziona Esegui con le mie credenziali utente.
    • Per utilizzare un service account 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 service account, la configurazione del flusso di lavoro utilizza il service account del repository.

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

    Per verificare che Dataform esegua l'ultimo risultato della compilazione nella configurazione di rilascio corrispondente, mantieni una pausa di almeno un'ora tra l'ora di creazione del risultato della compilazione e l'ora di 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 flusso di lavoro, fai clic su Tutte le azioni.
    • Per eseguire le azioni selezionate nel flusso di lavoro, fai clic su Selezione delle azioni e poi seleziona le azioni.
    • Per eseguire azioni con i tag selezionati, fai clic su Selezione dei tag e poi 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 elementi 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 ricompilarle 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 iniziare a essere eseguite 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 (Anteprima).

Ad esempio, la seguente configurazione del flusso di lavoro 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.

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

Per revocare l'autorizzazione che hai concesso:

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

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

Modificare una configurazione del workflow

Per modificare una configurazione del flusso di lavoro:

  1. Nel repository, vai a Releases & Scheduling (Uscite e programmazione).
  2. Accanto alla configurazione del flusso di lavoro da modificare, fai clic sul menu Altro e poi su Modifica.
  3. Nel riquadro Modifica configurazione del flusso di lavoro, modifica le impostazioni della configurazione del flusso di lavoro e poi fai clic su Salva.

Elimina una configurazione del workflow

Per eliminare una configurazione del flusso di lavoro:

  1. Nel repository, vai a Releases & Scheduling (Uscite e programmazione).
  2. Accanto alla configurazione del flusso di lavoro 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.

Pianificare 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 del workflow pianificate

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

Workflows esegue il workflow Dataform in un processo in due passaggi. Innanzitutto, estrae il codice del repository Dataform dal tuo provider Git e lo compila in un risultato di compilazione. Poi utilizza il risultato della compilazione per creare un workflow Dataform e lo esegue con la frequenza che hai impostato.

Crea un workflow di orchestrazione pianificato

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

  1. Workflows utilizza i service account per concedere ai workflow l'accesso alle Google Cloud risorse. 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/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}

    Sostituisci quanto segue:

    • PROJECT_ID: l'ID del tuo Google Cloud progetto.
    • REPOSITORY_LOCATION: la posizione del repository Dataform.
    • REPOSITORY_ID: il nome del repository Dataform.
    • GIT_COMMITISH: il ramo Git da cui vuoi eseguire il codice Dataform. Per un repository appena creato, sostituisci con main.

  3. Pianifica il flusso di lavoro di orchestrazione utilizzando Cloud Scheduler.

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

Puoi aggiornare il workflow di orchestrazione esistente e definire le impostazioni della richiesta di creazione del risultato di compilazione del workflow 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/v1beta1/" + repository + "/compilationResults"}
            auth:
                type: OAuth2
            body:
                gitCommitish: GIT_COMMITISH
                codeCompilationConfig:
                    schemaSuffix: dev

Puoi anche trasmettere 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 la sezione Passaggio di 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 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 di createWorkflowInvocation con il seguente snippet di codice:

    - 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

Puoi anche trasmettere 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 la sezione Passaggio di argomenti di runtime in una richiesta di esecuzione.

Pianificare le esecuzioni con Cloud Composer

Puoi utilizzare Cloud Composer 2 per pianificare le esecuzioni di Dataform. Dataform non supporta Cloud Composer 1.

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

Dataform fornisce vari operatori Airflow. Sono inclusi operatori per ottenere un risultato di compilazione, ottenere una chiamata del workflow e annullare una chiamata 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 Cloud Composer 2 versioni 2.0.25 e successive, questo pacchetto è preinstallato nel tuo ambiente. Non è necessario installarlo.

Se utilizzi versioni precedenti di Cloud Composer 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 Dataform

Per gestire le esecuzioni pianificate dei workflow Dataform con Cloud Composer 2, scrivi il DAG utilizzando gli operatori Dataform Airflow, poi 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 flusso di lavoro 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: il tuo ID progetto Google Cloud Dataform.
  • 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 nel repository Git remoto della versione del codice che vuoi utilizzare, ad esempio un ramo o uno SHA Git.

Il seguente esempio di codice mostra un DAG Airflow che esegue le seguenti operazioni:

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

Sostituisci quanto segue:

  • PROJECT_ID: il tuo ID progetto Google Cloud Dataform.
  • 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 nel repository Git remoto della versione del codice che vuoi utilizzare, ad esempio un ramo o uno SHA Git.
  • COMPILATION_RESULT: il nome del risultato della compilazione che vuoi utilizzare per questa chiamata del workflow.

Aggiungere parametri di configurazione della compilazione

Puoi aggiungere altri parametri di configurazione della compilazione all'oggetto create_compilation_result Airflow DAG. 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: il tuo ID progetto Google Cloud Dataform.
    • REPOSITORY_ID: il nome del repository Dataform.
    • REGION: la regione in cui si trova il repository Dataform.
    • GIT_COMMITISH: il commitish Git nel repository Git remoto della versione del codice che vuoi utilizzare, ad esempio un ramo o uno SHA Git.
    • PARAMETER: il parametro selezionato CodeCompilationConfig. Puoi aggiungere più parametri.
    • PARAMETER_VALUE: il valore del parametro selezionato.

Il seguente codice campione 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 parametri di configurazione di chiamata del workflow

Puoi aggiungere parametri di configurazione aggiuntivi per l'invocazione del workflow all'oggetto create_workflow_invocation DAG di Airflow. Per saperne di più sui parametri disponibili, consulta il riferimento API Dataform InvocationConfig.

  • Per aggiungere i parametri di configurazione dell'invocazione del workflow all'oggetto DAG di create_workflow_invocation Airflow, 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: il tuo ID progetto Google Cloud Dataform.
    • REPOSITORY_ID: il nome del repository Dataform.
    • REGION: la regione in cui si trova il repository Dataform.
    • PARAMETER: il parametro selezionato InvocationConfig. 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 create_workflow_invocation DAG di Airflow:

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

Automatizzare le esecuzioni con i trigger Cloud Build

Se vuoi andare oltre le pianificazioni basate sul tempo in una configurazione di rilascio, puoi utilizzare un trigger 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 ramo Git e attiva immediatamente una chiamata del flusso di lavoro Dataform per aggiornare i dati.

Preparare le risorse

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

    Attiva l'API Dataform

    Abilita l'API Cloud Build

  2. Assicurati di disporre di quanto segue:

Concedi le autorizzazioni IAM richieste

Concedi il ruolo Amministratore Dataform (roles/dataform.admin) al service account personalizzato nel tuo 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 invocazioni del workflow. Per informazioni dettagliate su come concedere un ruolo IAM a un singolo repository, consulta Controllare l'accesso a un singolo repository.

Concedi il ruolo Utente service account (roles/iam.serviceAccountUser) nel service account personalizzato della configurazione del flusso di lavoro al service account del trigger Cloud Build. Per ulteriori informazioni su questo requisito, vedi Utilizzare la modalità actAs rigorosa.

Affinché Cloud Build utilizzi il tuo service account personalizzato, devi concedere all'agente di servizio Cloud Build l'autorizzazione ad agire come questo account. Per concedere l'autorizzazione di rappresentazione all'agente di servizio Cloud Build:

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

    Vai a Service account

  2. Seleziona il 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 del service agent Cloud Build, che deve essere nel seguente formato:

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

    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 Trovare 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 radice del repository Git, crea un file cloudbuild.yaml. Utilizza questo file per definire il seguente script in più passaggi per creare un risultato di compilazione, aggiornare la configurazione della release per impostare questo risultato di compilazione come live 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 esegue la configurazione della build quando il codice viene inviato al repository, procedi nel seguente modo:

  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 ramo sul ramo 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 valori:

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

  12. Nella sezione Service account, seleziona il service account personalizzato.

  13. Fai clic su Crea.

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

Testa l'attivatore

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

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

    Vai alla cronologia build

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

    Vai a Dataform

  4. Seleziona il repository.

  5. Fai clic su Release e pianificazione 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 live per la configurazione della release.

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

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

Passaggi successivi