Programar execuções

Este documento mostra como fazer o seguinte no Dataform:

A tabela a seguir compara os métodos:

Método Meta Tipo de gatilho
Configurações de fluxo de trabalho Execuções de produção padrão baseadas em tempo no Dataform. Por períodos
Workflows e Cloud Scheduler Orquestração leve e sem servidor do Dataform com outras APIs. Baseado em tempo ou orientado por eventos
Cloud Composer Pipelines complexos com dependências fora do BigQuery. Baseado em tempo ou orientado por eventos
Gatilhos do Cloud Build Automatizar lançamentos imediatamente após um push do Git. Orientada por eventos

Antes de começar

Para programar execuções com configurações de fluxo de trabalho ou programar execuções com fluxos de trabalho e o Cloud Scheduler, faça o seguinte:

  1. No Google Cloud console, acesse a página Dataform.

    Acesse o Dataform

  2. Selecione ou crie um repositório.

  3. Crie uma configuração de versão.

Para programar execuções com o Cloud Composer, faça o seguinte:

  1. Selecione ou crie um repositório do Dataform.
  2. Conceder acesso ao BigQuery para o Dataform.
  3. Selecione ou crie um espaço de trabalho do Dataform.
  4. Crie pelo menos uma tabela.
  5. Crie um ambiente do Cloud Composer 2.

Funções exigidas

Para conseguir as permissões necessárias a fim de concluir as tarefas neste documento, peça ao administrador para conceder a você os seguintes papéis do IAM:

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.

Para usar uma conta de serviço personalizada ao criar uma configuração de fluxo de trabalho, conceda acesso a ela.

Para usar as credenciais de usuário da Conta do Google ao criar uma configuração de fluxo de trabalho (Pré-lançamento), conceda acesso à Conta do Google.

Para ativar as execuções programadas de uma configuração de fluxo de trabalho, conceda a permissão iam.serviceAccounts.actAs ao agente de serviço padrão do Dataform da conta de serviço personalizada usada na configuração do fluxo de trabalho. Essa permissão está disponível no papel de usuário da conta de serviço (roles/iam.serviceAccountUser). Para mais informações, consulte Usar o modo de agir como estrito.

Para aumentar a segurança do agendamento, consulte Implementar permissões de agendamento aprimoradas.

Programar execuções com configurações de fluxo de trabalho

Nesta seção, mostramos como criar uma configuração de fluxo de trabalho no Dataform para programar e configurar execuções de fluxo de trabalho. É possível usar configurações de fluxo de trabalho para executar fluxos de trabalho do Dataform de acordo com uma programação.

Sobre as configurações de fluxo de trabalho

Para programar execuções do Dataform de todas ou de algumas ações de fluxo de trabalho no BigQuery, crie configurações de fluxo de trabalho. Em uma configuração de fluxo de trabalho, você seleciona uma configuração de lançamento de compilação, escolhe ações de fluxo de trabalho para execução e define a programação de execução.

Em seguida, durante uma execução programada da configuração do fluxo de trabalho, o Dataform implanta no BigQuery a seleção de ações do resultado da compilação mais recente na configuração de lançamento. Também é possível acionar manualmente a execução de uma configuração de fluxo de trabalho com a API Dataform workflowConfigs.

Uma configuração de fluxo de trabalho do Dataform contém as seguintes configurações de execução:

  • ID da configuração do fluxo de trabalho.
  • Configuração de lançamento.

  • Conta de serviço.

    Essa é a conta de serviço personalizada associada à configuração do fluxo de trabalho. Você pode selecionar uma conta de serviço personalizada associada ao seu projeto Google Cloud ou inserir manualmente uma conta de serviço diferente. Por padrão, as configurações de fluxo de trabalho usam as mesmas contas de serviço que os repositórios.

    As credenciais da conta de serviço são o método de autorização padrão para criação e execução de configurações de fluxo de trabalho programado.

  • Credenciais de usuário da Conta do Google (prévia)

    As credenciais de usuário da Conta do Google são o método de autorização padrão para criações e execuções de configuração de fluxo de trabalho manuais e não programadas. Para mais informações, consulte Autorizar sua Conta do Google.

  • Ações do fluxo de trabalho a serem executadas:

    • Todas as ações.
    • Seleção de ações.
    • Seleção de tags.

  • Programação de execução e fuso horário.

Criar uma configuração de fluxo de trabalho

Para criar uma configuração de fluxo de trabalho do Dataform, siga estas etapas:

  1. No repositório, acesse Lançamentos e programação.
  2. Na seção Configurações do fluxo de trabalho, clique em Criar.

  3. No painel Criar configuração do fluxo de trabalho, no campo ID da configuração, insira um ID exclusivo para a configuração do fluxo de trabalho.

    Os IDs podem incluir apenas números, letras, hifens e sublinhados.

  4. No menu Configuração da versão, selecione uma configuração de versão de compilação.

  5. Na seção Autenticação, autorize a configuração do fluxo de trabalho com as credenciais de usuário da sua Conta do Google ou uma conta de serviço.

    • Para usar as credenciais de usuário da sua Conta do Google (Prévia), selecione Executar com minhas credenciais de usuário.
    • Para usar uma conta de serviço personalizada, selecione Executar com a conta de serviço selecionada e escolha a conta associada ao projeto Google Cloud a que você tem acesso. Se você não selecionar uma conta de serviço, a configuração do fluxo de trabalho usará a conta de serviço do repositório.

  6. Opcional: no campo Frequência de programação, insira a frequência de execuções no formato unix-cron.

    Para verificar se o Dataform executa o resultado da compilação mais recente na configuração de lançamento correspondente, mantenha um intervalo mínimo de uma hora entre o momento da criação do resultado da compilação e o momento da execução programada.

  7. Opcional: no menu Fuso horário, selecione o fuso horário das execuções.

    O fuso horário padrão é UTC.

  8. Selecione as ações do fluxo de trabalho a serem executadas:

    • Para executar todo o fluxo de trabalho, clique em Todas as ações.
    • Para executar as ações selecionadas no fluxo de trabalho, clique em Seleção de ações e escolha as ações.
    • Para executar ações com as tags selecionadas, clique em Seleção de tags e escolha as tags.
    • Opcional: para executar as ações ou tags selecionadas e as dependências delas, selecione a opção Incluir dependências.
    • Opcional: para executar as ações ou tags selecionadas e os dependentes delas, selecione a opção Incluir dependentes.

    • Opcional: para recriar todas as tabelas do zero, selecione a opção Executar com atualização completa.

      Sem essa opção, o Dataform atualiza as tabelas incrementais sem recriá-las do zero.

    • Opcional: defina a prioridade do job de consulta do BigQuery com a opção Executar como job interativo com alta prioridade (padrão). Por padrão, o BigQuery executa consultas como jobs de consulta interativos, que são projetados para começar a ser executados o mais rápido possível. Desmarcar essa opção executa as consultas como jobs de consulta em lote, que têm prioridade mais baixa.

  9. Clique em Criar. Se você selecionou Executar com minhas credenciais de usuário como método de autenticação, autorize sua Conta do Google (Prévia).

Por exemplo, a configuração de fluxo de trabalho a seguir executa ações com a tag hourly a cada hora no fuso horário CEST:

  • ID da configuração: production-hourly
  • Configuração de versão: -
  • Frequência: 0 * * * *
  • Fuso horário: Central European Summer Time (CEST)
  • Seleção de ações do fluxo de trabalho: seleção de tags, tag hourly

Autorizar sua Conta do Google

Para autenticar o recurso com as credenciais de usuário da sua Conta do Google, conceda permissão manualmente para que os pipelines do BigQuery recebam o token de acesso da sua Conta do Google e acessem os dados de origem em seu nome. É possível conceder aprovação manual com a interface da caixa de diálogo do OAuth.

Você só precisa conceder permissão aos pipelines do BigQuery uma vez.

Para revogar a permissão concedida, siga estas etapas:

  1. Acesse a página da sua Conta do Google.
  2. Clique em Pipelines do BigQuery.
  3. Clique em Remover acesso.

Alterar o proprietário da configuração do fluxo de trabalho atualizando as credenciais também requer aprovação manual se o novo proprietário da Conta do Google nunca tiver criado uma configuração de fluxo de trabalho antes.

Editar uma configuração de fluxo de trabalho

Para editar uma configuração de fluxo de trabalho, siga estas etapas:

  1. No repositório, acesse Lançamentos e programação.
  2. Na configuração do fluxo de trabalho que você quer editar, clique no menu Mais e em Editar.
  3. No painel Editar configuração do fluxo de trabalho, edite as configurações do fluxo de trabalho e clique em Salvar.

Excluir uma configuração de fluxo de trabalho

Para excluir uma configuração de fluxo de trabalho, siga estas etapas:

  1. No repositório, acesse Lançamentos e programação.
  2. Na configuração do fluxo de trabalho que você quer excluir, clique no menu Mais e em Excluir.
  3. Na caixa de diálogo Excluir configuração da versão, clique em Excluir.

Programar execuções com o Workflows e o Cloud Scheduler

Nesta seção, mostramos como programar execuções de fluxos de trabalho do Dataform usando o Workflows e o Cloud Scheduler.

Sobre execuções de fluxo de trabalho programadas

É possível definir a frequência das execuções do fluxo de trabalho do Dataform criando um job do Cloud Scheduler que aciona um fluxo de trabalho do Workflows. O Workflows executa serviços em um fluxo de trabalho de orquestração definido por você.

O Workflows executa seu fluxo de trabalho do Dataform em um processo de duas etapas. Primeiro, ele extrai o código do repositório do Dataform do seu provedor Git e o compila em um resultado de compilação. Em seguida, ele usa o resultado da compilação para criar um fluxo de trabalho do Dataform e o executa na frequência definida.

Criar um fluxo de trabalho de orquestração programado

Para programar execuções do fluxo de trabalho do Dataform, use o Workflows para criar um fluxo de trabalho de orquestração e adicione um job do Cloud Scheduler como um gatilho.

  1. O Workflows usa contas de serviço para dar acesso aos fluxos de trabalho aos recursos do Google Cloud . Crie uma conta de serviço e conceda a ela as seguintes permissões:

  2. Crie um fluxo de trabalho de orquestração e use o seguinte código-fonte YAML como definição do fluxo de trabalho:

    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}

    Substitua:

    • PROJECT_ID: o ID do seu projeto do Google Cloud .
    • REPOSITORY_LOCATION: o local do repositório do Dataform.
    • REPOSITORY_ID: o nome do seu repositório do Dataform.
    • GIT_COMMITISH: a ramificação do Git de onde você quer executar o código do Dataform. Para um repositório recém-criado, substitua por main.

  3. Programe o fluxo de trabalho de orquestração usando o Cloud Scheduler.

Personalizar a solicitação de resultado da compilação de criação do fluxo de trabalho do Dataform

É possível atualizar o fluxo de trabalho de orquestração atual e definir as configurações de solicitação de resultado da compilação de criação do fluxo de trabalho do Dataform no formato YAML. Para mais informações sobre as configurações, consulte a referência do recurso REST projects.locations.repositories.compilationResults.

Por exemplo, para adicionar uma configuração _dev schemaSuffix a todas as ações durante a compilação, substitua o corpo da etapa createCompilationResult pelo snippet de código a seguir:

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

Também é possível transmitir outras configurações como argumentos de ambiente de execução em uma solicitação de execução do Workflows e acessar esses argumentos usando variáveis. Para mais informações, consulte Transmitir argumentos de ambiente de execução em uma solicitação de execução.

Personalizar a solicitação de invocação do fluxo de trabalho do Dataform

É possível atualizar o fluxo de trabalho de orquestração atual e definir as configurações de solicitação de invocação do fluxo de trabalho do Dataform no formato YAML. Para mais informações sobre as configurações de solicitação de invocação, consulte a referência do recurso REST projects.locations.repositories.workflowInvocations.

Por exemplo, para executar apenas ações com a tag hourly com todas as dependências transitivas incluídas, substitua o corpo createWorkflowInvocation pelo snippet de código a seguir:

    - 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

Também é possível transmitir outras configurações como argumentos de ambiente de execução em uma solicitação de execução do Workflows e acessar esses argumentos usando variáveis. Para mais informações, consulte Transmitir argumentos de ambiente de execução em uma solicitação de execução.

Programar execuções com o Cloud Composer

Use o Cloud Composer 2 para programar execuções do Dataform. O Dataform não é compatível com o Cloud Composer 1.

Para gerenciar programações de execuções do Dataform com o Cloud Composer 2, use os operadores do Dataform em grafos acíclicos dirigidos (DAGs) do Airflow. É possível criar um DAG do Airflow que programa invocações de fluxo de trabalho do Dataform.

O Dataform oferece vários operadores do Airflow. Isso inclui operadores para receber um resultado de compilação, uma invocação de fluxo de trabalho e cancelar uma invocação de fluxo de trabalho. Para conferir a lista completa de operadores do Dataform Airflow disponíveis, consulte Operadores do Google Dataform.

Instale o pacote google-cloud-dataform do PyPi

Se você usa as versões 2.0.25 e mais recentes do Cloud Composer 2, esse pacote é pré-instalado no seu ambiente. Não é necessário instalar nada.

Se você usa versões anteriores do Cloud Composer 2, instale o pacote google-cloud-dataform PyPi.

Na seção "Pacotes PyPI", especifique a versão ==0.2.0.

Criar um DAG do Airflow que programa invocações de fluxo de trabalho do Dataform

Para gerenciar execuções programadas de fluxos de trabalho do Dataform com o Cloud Composer 2, escreva o DAG usando os operadores do Dataform Airflow e faça upload dele para o bucket do seu ambiente.

O exemplo de código a seguir mostra um DAG do Airflow que cria um resultado de compilação do Dataform e inicia uma invocação de fluxo de trabalho do 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

Substitua:

  • PROJECT_ID: o ID do projeto do Dataform Google Cloud .
  • REPOSITORY_ID: o nome do seu repositório do Dataform.
  • REGION: a região em que o repositório do Dataform está localizado.
  • COMPILATION_RESULT: o nome do resultado da compilação que você quer usar para essa invocação de fluxo de trabalho.
  • GIT_COMMITISH: o commitish do Git no repositório Git remoto da versão do código que você quer usar, por exemplo, uma ramificação ou um SHA do Git.

O exemplo de código a seguir mostra um DAG do Airflow que realiza as seguintes ações:

  1. Cria um resultado de compilação do Dataform.
  2. Inicia uma invocação assíncrona de fluxo de trabalho do Dataform.
  3. Pesquisa o status do fluxo de trabalho até que ele entre no estado esperado usando 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

Substitua:

  • PROJECT_ID: o Google Cloud projectID do Dataform.
  • REPOSITORY_ID: o nome do seu repositório do Dataform.
  • REGION: a região em que o repositório do Dataform está localizado.
  • COMPILATION_RESULT: o nome do resultado da compilação que você quer usar para essa invocação de fluxo de trabalho.
  • GIT_COMMITISH: o commitish do Git no repositório Git remoto da versão do código que você quer usar, por exemplo, uma ramificação ou um SHA do Git.
  • COMPILATION_RESULT: o nome do resultado da compilação que você quer usar para essa invocação de fluxo de trabalho.

Adicionar parâmetros de configuração de compilação

É possível adicionar outros parâmetros de configuração de compilação ao objeto DAG do Airflow create_compilation_result. Para mais informações sobre parâmetros disponíveis, consulte a referência da API Dataform CodeCompilationConfig.

  • Para adicionar parâmetros de configuração de compilação ao objeto DAG do Airflow create_compilation_result, adicione os parâmetros selecionados ao campo code_compilation_config no seguinte 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"}
        },
    )

    Substitua:

    • PROJECT_ID: o ID do projeto do Dataform Google Cloud .
    • REPOSITORY_ID: o nome do seu repositório do Dataform.
    • REGION: a região em que o repositório do Dataform está localizado.
    • GIT_COMMITISH: o commitish do Git no repositório Git remoto da versão do código que você quer usar, por exemplo, uma ramificação ou um SHA do Git.
    • PARAMETER: o CodeCompilationConfigparâmetro selecionado. É possível adicionar vários parâmetros.
    • PARAMETER_VALUE: o valor do parâmetro selecionado.

O exemplo de código a seguir mostra o parâmetro defaultDatabase adicionado ao objeto DAG do 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"}
        },
    )

Adicionar parâmetros de configuração de invocação do fluxo de trabalho

É possível adicionar outros parâmetros de configuração de invocação de fluxo de trabalho ao objeto DAG do Airflow create_workflow_invocation. Para mais informações sobre parâmetros disponíveis, consulte a referência da API Dataform InvocationConfig.

  • Para adicionar parâmetros de configuração de invocação de fluxo de trabalho ao objeto DAG do Airflow create_workflow_invocation, adicione os parâmetros selecionados ao campo invocation_config no seguinte 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 }
        },
    )

    Substitua:

    • PROJECT_ID: o ID do projeto do Dataform Google Cloud .
    • REPOSITORY_ID: o nome do seu repositório do Dataform.
    • REGION: a região em que o repositório do Dataform está localizado.
    • PARAMETER: o InvocationConfigparâmetro selecionado. É possível adicionar vários parâmetros.
    • PARAMETER_VALUE: o valor do parâmetro selecionado.

O exemplo de código a seguir mostra os parâmetros includedTags[] e transitiveDependenciesIncluded adicionados ao objeto DAG do 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 }
        },
    )

Automatizar execuções com gatilhos do Cloud Build

Se você quiser ir além dos programações baseadas em tempo em uma configuração de lançamento, use um gatilho do Cloud Build para criar um pipeline orientado a eventos. Essa abordagem compila automaticamente seu código sempre que um novo commit é enviado para uma ramificação do Git e aciona imediatamente uma invocação de fluxo de trabalho do Dataform para atualizar seus dados.

Preparar os recursos

  1. No projeto do Google Cloud , ative as APIs Dataform e Cloud Build:

    Ativar a API Dataform

    Ativar a API Cloud Build

  2. Verifique se você tem o seguinte:

Conceder as permissões necessárias do IAM

Conceda o papel de administrador do Dataform (roles/dataform.admin) à conta de serviço personalizada no seu repositório do Dataform. Esse papel oferece acesso total ao repositório, incluindo a permissão para criar resultados de compilação, atualizar configurações de lançamento e iniciar novas invocações de fluxo de trabalho. Para detalhes sobre como conceder um papel do IAM a um repositório individual, consulte Controlar o acesso a um repositório individual.

Conceda o papel de usuário da conta de serviço (roles/iam.serviceAccountUser) na conta de serviço personalizada da configuração do fluxo de trabalho à conta de serviço do gatilho do Cloud Build. Para mais informações sobre esse requisito, consulte Usar o modo estrito "agir como".

Para que o Cloud Build use sua conta de serviço personalizada, é necessário conceder ao agente de serviço do Cloud Build permissão para agir como essa conta. Para conceder permissão de representação ao agente de serviço do Cloud Build, faça o seguinte:

  1. No console do Google Cloud , acesse a página Contas de serviço.

    Acessar a página "Contas de serviço"

  2. Selecione sua conta de serviço personalizada.

  3. Acesse a guia Principais com acesso.

  4. Clique em Conceder acesso.

  5. No campo Novos principais, insira o endereço de e-mail do agente de serviço do Cloud Build, que deve estar neste formato:

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

    Substitua PROJECT_NUMBER pelo ID numérico do seu projeto do Google Cloud . Encontre o ID do projeto Google Cloud no painel do consoleGoogle Cloud . Para mais informações, consulte Encontrar o nome, o número e o ID do projeto.

  6. No menu Selecionar um papel, escolha Usuário da conta de serviço.

  7. Clique em Salvar.

Crie o arquivo de configuração cloudbuild.yaml

Na raiz do repositório Git, crie um arquivo cloudbuild.yaml. Use este arquivo para definir o seguinte script de várias etapas para criar um resultado de compilação, atualizar a configuração de lançamento para definir esse resultado de compilação como ativo e iniciar uma nova invocação de fluxo de trabalho.

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

Criar o gatilho do Cloud Build

Para criar um gatilho que execute sua configuração de build quando o código for enviado para seu repositório, faça o seguinte:

  1. No console Google Cloud , abra a página Gatilhos do Cloud Build.

    Acessar "Acionadores"

  2. Se você não conectou seu repositório Git, clique em Conectar repositório e siga as etapas.

  3. Clique em Criar gatilho.

  4. Insira um nome para o acionador.

  5. Selecione uma região para o acionador.

  6. Selecione um evento para o gatilho.

  7. Na seção Origem, defina o repositório como seu repositório Git conectado.

  8. Defina a ramificação principal do repositório.

  9. Na seção Configuração, selecione o arquivo de configuração do Cloud Build, que pode ser um arquivo YAML ou JSON.

  10. Defina o local do arquivo como /cloudbuild.yaml ou o caminho para o arquivo.

  11. Na seção Variáveis de substituição, adicione as seguintes variáveis e valores:

    • _DATAFORM_REPO_ID: o ID do repositório do Dataform
    • _RELEASE_CONFIG_ID: o ID da configuração de lançamento do Dataform
    • _WORKFLOW_CONFIG_ID: o ID da configuração do fluxo de trabalho do Dataform
    • Opcional: _DATAFORM_LOCATION: a região do seu repositório do Dataform, por exemplo, us-central1

  12. Na seção Conta de serviço, selecione sua conta de serviço personalizada.

  13. Clique em Criar.

Para mais informações, consulte Criar um gatilho de build.

Testar o gatilho

  1. Confirme e envie o arquivo cloudbuild.yaml para a ramificação que o gatilho está monitorando.

  2. Para ver o build do Cloud Build, abra a página Histórico de builds no console Google Cloud .

    Acesse Histórico de criação

  3. Se a compilação for bem-sucedida, acesse a página Dataform.

    Acesse o Dataform

  4. Selecione seu Repositório.

  5. Clique em Lançamentos e programação e selecione a configuração de lançamento.

  6. Na lista Resultados de compilação manual / da API, procure uma nova entrada. A compilação bem-sucedida mais recente deve ser marcada como o Resultado da compilação dinâmica para a configuração de lançamento.

  7. Clique em Registros de execução de fluxo de trabalho.

  8. Você vai ver uma nova invocação de fluxo de trabalho iniciada usando a configuração selecionada.

A seguir