Como configurar um pipeline de CI/CD para seu fluxo de trabalho de processamento de dados

Neste tutorial, descrevemos como configurar um pipeline de integração/implantação contínuas (CI/CD) para processar dados implementando métodos de CI/CD com produtos gerenciados no Google Cloud. Os cientistas e analistas de dados podem adaptar as metodologias das práticas de CI/CD para garantir alta qualidade, facilidade de manutenção e de adaptação dos processos de dados e fluxos de trabalho. É possível aplicar os seguintes métodos:

  • Controle de versão do código-fonte
  • Desenvolvimento, teste e implantação automáticos de apps
  • Isolamento de ambiente e separação da produção
  • Replicação de procedimentos para configuração de ambiente

Este tutorial visa ajudar os cientistas e analistas de dados que criam jobs recorrentes de processamento de dados a estruturar o processo de pesquisa e desenvolvimento (P&D) de forma a sistematizar e automatizar as cargas de trabalho.

Arquitetura de implantação

Neste guia, você usa os seguintes produtos do Google Cloud:

  • O Cloud Build para desenvolver um pipeline de CI/CD e criar, implantar e testar o fluxo de trabalho de processamento de dados e o próprio processamento de dados. O Cloud Build é um serviço gerenciado que executa seu build no Google Cloud. Um build é uma série de etapas de compilação em que cada uma é executada em um contêiner do Docker.
  • O Cloud Composer para definir e executar as etapas do fluxo de trabalho, como iniciar o processamento de dados, testar e verificar os resultados. O Cloud Composer é um serviço gerenciado do Apache Airflow (em inglês), que oferece um ambiente em que é possível criar, programar, monitorar e gerenciar fluxos de trabalho complexos, como o de processamento de dados mostrado neste tutorial.
  • O Dataflow para executar o exemplo WordCount (em inglês) do Apache Beam como um processo de dados de amostra.

Pipeline de CI/CD

De modo geral, o pipeline de CI/CD consiste nas seguintes etapas:

  1. O Cloud Build empacota a amostra WordCount em um arquivo Java Archive (JAR) de execução automática usando o Maven Builder (em inglês), que é um contêiner com o Maven instalado. Quando uma etapa de compilação é configurada para usar o Maven Builder, o Maven executa as tarefas.
  2. O Cloud Build carrega o arquivo JAR no Cloud Storage.
  3. O Cloud Build executa testes de unidade no código do fluxo de trabalho de processamento de dados e implanta esse código no Cloud Composer.
  4. O Cloud Composer coleta o arquivo JAR e executa o job de processamento de dados no Dataflow.

Veja no diagrama a seguir uma visualização detalhada das etapas do pipeline de CI/CD.

Diagrama arquitetônico do pipeline de CI/CD.

Neste tutorial, as implantações nos ambientes de teste e produção são separadas em dois pipelines diferentes do Cloud Build, um de teste e outro de produção.

No diagrama anterior, o pipeline de teste consiste nas seguintes etapas:

  1. Um desenvolvedor confirma as alterações de código no Cloud Source Repositories.
  2. As alterações acionam uma compilação de teste no Cloud Build.
  3. O Cloud Build cria o arquivo JAR autoexecutável e o implanta no bucket do JAR de teste no Cloud Storage.
  4. O Cloud Build implanta os arquivos de teste nos buckets do arquivo de teste no Cloud Storage.
  5. O Cloud Build define a variável no Cloud Composer para fazer referência ao arquivo JAR recém-implantado.
  6. O Cloud Build testa o fluxo de trabalho Directed Acyclic Graph (DAG) (em inglês) de processamento de dados e o implanta no bucket do Cloud Composer no Cloud Storage.
  7. O arquivo DAG do fluxo de trabalho é implantado no Cloud Composer.
  8. O Cloud Build aciona a execução do fluxo de trabalho de processamento de dados recém-implantado.

No diagrama anterior, o pipeline de produção consiste nas seguintes etapas:

  1. Um desenvolvedor executa manualmente o pipeline de implantação na produção no Cloud Build.
  2. O Cloud Build copia o arquivo JAR autoexecutável mais recente do bucket do JAR de teste para o bucket do JAR de produção no Cloud Storage.
  3. O Cloud Build testa o DAG do fluxo de trabalho de processamento de dados de produção e o implanta no bucket do Cloud Composer no Cloud Storage.
  4. O arquivo DAG do fluxo de trabalho de produção é implantado no Cloud Composer.

Neste tutorial, o fluxo de trabalho de processamento de dados de produção é implantado no mesmo ambiente do Cloud Composer que o fluxo de teste para fornecer uma visão consolidada de todas as tarefas de processamento de dados. Para este tutorial, os ambientes são separados usando diferentes buckets do Cloud Storage de modo a armazenar os dados de entrada e saída.

Se você quiser separar completamente os ambientes, precisará criar vários ambientes do Cloud Composer em diferentes projetos, que são separados um do outro por padrão. Essa separação ajuda a proteger seu ambiente de produção. No entanto, esse procedimento não faz parte do escopo deste tutorial. Para mais informações de como acessar recursos em vários projetos do Google Cloud, consulte Como definir permissões de conta de serviço.

Fluxo de trabalho de processamento de dados

As instruções de como o Cloud Composer executa o fluxo de trabalho de processamento de dados são definidas em um Directed Acyclic Graph (DAG) (em inglês) escrito em Python. No DAG, todas as etapas do fluxo são indicadas juntamente com as dependências entre elas.

O pipeline de CI/CD implanta automaticamente a definição do DAG do Cloud Source Repositories para o Cloud Composer em cada compilação. Esse processo garante que o Cloud Composer esteja sempre atualizado com as instruções mais recentes de fluxo de trabalho, sem precisar de intervenção humana.

Além do fluxo de trabalho de processamento de dados, a definição do DAG para o ambiente de teste também contém instruções da etapa completa de teste, que ajuda a garantir a execução correta do processamento de dados.

O fluxo de trabalho de processamento de dados está ilustrado no diagrama a seguir.

As quatro etapas do fluxo de trabalho de processamento de dados.

O fluxo de trabalho de processamento de dados consiste nas seguintes etapas:

  1. Executar o processo de dados WordCount no Dataflow.
  2. Fazer o download dos arquivos de saída do processo WordCount, que gera três arquivos:

    • download_result_1
    • download_result_2
    • download_result_3
  3. Fazer o download do arquivo de referência chamado download_ref_string.

  4. Comparar o resultado com o arquivo de referência. Esse teste de integração agrega as três saídas e compara os resultados com o arquivo de referência.

Usar uma estrutura de orquestração de tarefas, como o Cloud Composer, para gerenciar o fluxo de trabalho de processamento de dados ajuda a reduzir a complexidade do código do fluxo.

Testes

Além do teste de integração que verifica todo o fluxo de trabalho de processamento de dados, este tutorial inclui dois testes de unidade. Os testes de unidade são testes automáticos no código de processamento de dados e do fluxo de trabalho de processamento de dados. O teste no código de processamento de dados é escrito em Java e executado automaticamente durante o processo de compilação do Maven. O teste no código do fluxo de trabalho de processamento de dados é escrito em Python e executado como uma etapa de compilação independente.

Objetivos

  • Configurar o ambiente do Cloud Composer.
  • Criar buckets do Cloud Storage para seus dados.
  • Criar os pipelines de compilação, teste e produção.
  • Configurar o acionador da compilação.

Custos

Neste tutorial, usamos os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem ser qualificados para uma avaliação gratuita.

Ao concluir este tutorial, exclua os recursos criados para evitar o faturamento contínuo. Para mais informações, consulte Como fazer a limpeza.

Antes de começar

  1. Faça login na sua conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar a página do seletor de projetos

  3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

  4. Ative as APIs Cloud Build, Cloud Source Repositories, Cloud Composer, and Dataflow.

    Ative as APIs

Código de amostra

Você encontrará o código de amostra em duas pastas:

  • A pasta env-setup contém scripts de shell para a configuração inicial do ambiente do Google Cloud.
  • A pasta source-code contém o código desenvolvido ao longo do tempo, que precisa ter a fonte controlada, e aciona os processos automáticos de compilação e teste. Ela inclui as seguintes subpastas:

    • A pasta data-processing-code contém o código-fonte do processo do Apache Beam.
    • A pasta workflow-dag contém as definições do DAG do compositor para os fluxos de trabalho de processamento de dados com as etapas para projetar, implementar e testar o processo do Dataflow.
    • A pasta build-pipeline contém duas configurações do Cloud Build: uma para o pipeline de teste e outra para o de produção. Ela também inclui um script de suporte para os pipelines.

Neste tutorial, os arquivos de código-fonte para o processamento de dados e o fluxo de trabalho do DAG estão em pastas diferentes no mesmo repositório. Em um ambiente de produção, os arquivos de código-fonte geralmente ficam nos respectivos repositórios e são gerenciados por equipes diferentes.

Como configurar o ambiente

Neste tutorial, todos os comandos serão executados no Cloud Shell. O Cloud Shell aparece como uma janela na parte inferior do Console do Google Cloud.

  1. No Console do Cloud, abra o Cloud Shell:

    Abrir o Cloud Shell

  2. Clone o repositório da amostra de código:

    git clone https://github.com/GoogleCloudPlatform/ci-cd-for-data-processing-workflow.git
    
  3. Execute um script para definir as variáveis de ambiente:

    cd ~/ci-cd-for-data-processing-workflow/env-setup
    source set_env.sh
    

    O script define as seguintes variáveis de ambiente:

    • ID do seu projeto do Google Cloud
    • Sua região e zona
    • O nome dos buckets do Cloud Storage usados pelo pipeline de compilação e pelo fluxo de trabalho de processamento de dados.

    As variáveis de ambiente não são armazenadas entre sessões. Portanto, se a sessão do Cloud Shell encerrar ou desconectar enquanto você estiver trabalhando no tutorial, será necessário redefinir as variáveis.

Como criar o ambiente do Cloud Composer

Neste tutorial, você configurará um ambiente do Cloud Composer que consiste nos nós n1-standard-1.

  1. Crie o ambiente do Cloud Composer no Cloud Shell:

    gcloud composer environments create $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION \
        --zone $COMPOSER_ZONE_ID \
        --machine-type n1-standard-1 \
        --node-count 3 \
        --disk-size 20 \
        --python-version 2
    
  2. Execute um script para definir as variáveis no ambiente do Cloud Composer. Elas são necessárias para os DAGs de processamento de dados.

    cd ~/ci-cd-for-data-processing-workflow/env-setup
    chmod +x set_composer_variables.sh
    ./set_composer_variables.sh
    

    O script define as seguintes variáveis de ambiente:

    • ID do seu projeto do Google Cloud
    • Sua região e zona
    • O nome dos buckets do Cloud Storage usados pelo pipeline de compilação e pelo fluxo de trabalho de processamento de dados.

Extrair as propriedades do ambiente do Cloud Composer

O Cloud Composer usa um bucket do Cloud Storage para armazenar os DAGs. Quando você move um arquivo de definição do DAG para o bucket, o Cloud Composer lê automaticamente os arquivos. O bucket do Cloud Storage para o Cloud Composer foi criado junto com o ambiente do Cloud Composer. Siga o procedimento a seguir para extrair o URL dos buckets e configure o pipeline de CI/CD para implantar automaticamente as definições do DAG no bucket do Cloud Storage.

  1. No Cloud Shell, exporte o URL do bucket como uma variável de ambiente:

    export COMPOSER_DAG_BUCKET=$(gcloud composer environments describe $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION \
        --format="get(config.dagGcsPrefix)")
    
  2. Exporte o nome da conta de serviço que o Cloud Composer usa para ter acesso aos buckets do Cloud Storage:

    export COMPOSER_SERVICE_ACCOUNT=$(gcloud composer environments describe $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION \
        --format="get(config.nodeConfig.serviceAccount)")
    

Criar os buckets do Cloud Storage

Nesta seção, você cria um conjunto de buckets do Cloud Storage para armazenar o seguinte:

  • Artefatos das etapas intermediárias do processo de compilação
  • Arquivos de entrada e saída do fluxo de trabalho de processamento de dados
  • Local de preparo dos jobs do Dataflow para armazenar os arquivos binários

Para criar os buckets do Cloud Storage, faça o seguinte:

  • No Cloud Shell, crie buckets do Cloud Storage e conceda permissão à conta de serviço do Cloud Composer para executar os fluxos de trabalho de processamento de dados:

    cd ~/ci-cd-for-data-processing-workflow/env-setup
    chmod +x create_buckets.sh
    ./create_buckets.sh
    

Enviar o código-fonte para o Cloud Source Repositories

Neste tutorial, você usará uma base de código-fonte no controle de versão. A etapa a seguir mostra como uma base de código é desenvolvida e alterada ao longo do tempo. Sempre que as alterações são enviadas ao repositório, o pipeline de compilação, implantação e teste é acionado.

  • No Cloud Shell, envie a pasta source-code para o Cloud Source Repositories:

    gcloud source repos create $SOURCE_CODE_REPO
    cp -r ~/ci-cd-for-data-processing-workflow/source-code ~/$SOURCE_CODE_REPO
    cd ~/$SOURCE_CODE_REPO
    git init
    git remote add google \
        https://source.developers.google.com/p/$GCP_PROJECT_ID/r/$SOURCE_CODE_REPO
    git add .
    git commit -m 'initial commit'
    git push google master
    

    Esses são os comandos padrão para inicializar o Git em um novo diretório e enviar o conteúdo para um repositório remoto.

Criar pipelines do Cloud Build

Nesta seção, serão criados os pipelines de compilação que geram, implantam e testam o fluxo de trabalho de processamento de dados.

Conceder acesso à conta de serviço do Cloud Build

O Cloud Build implanta os DAGs do Cloud Compose e aciona os fluxos de trabalho, que são ativados quando você adiciona outro acesso à conta de serviço do Cloud Build. Para mais informações sobre os diferentes papéis disponíveis ao trabalhar com o Cloud Composer, consulte a documentação de controle de acesso.

  1. No Cloud Shell, adicione o papel composer.admin à conta de serviço do Cloud Build para que o job do Cloud Build possa definir variáveis do Airflow no Cloud Composer:

    gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
        --member=serviceAccount:$PROJECT_NUMBER@cloudbuild.gserviceaccount.com \
        --role=roles/composer.admin
    
  2. Adicione o papel composer.worker à conta de serviço do Cloud Build para que o job do Cloud Build possa acionar o fluxo de trabalho de dados no Cloud Composer:

    gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
        --member=serviceAccount:$PROJECT_NUMBER@cloudbuild.gserviceaccount.com \
        --role=roles/composer.worker
    

Criar o pipeline de compilação e teste

As etapas do pipeline de compilação e teste são definidas no arquivo de configuração YAML. Neste tutorial, você usará imagens do builder predefinidas para git, maven, gsutil e gcloud a fim de executar as tarefas em cada etapa de compilação. As substituições de variáveis de configuração serão usadas para definir as configurações do ambiente no momento da compilação. Os locais do repositório do código-fonte e dos buckets do Cloud Storage serão definidos pelas substituições. A compilação precisa dessas informações para implantar o arquivo JAR, os arquivos de teste e a definição do DAG.

  • No Cloud Shell, envie o arquivo de configuração do pipeline de compilação para criar o pipeline no Cloud Build:

    cd ~/ci-cd-for-data-processing-workflow/source-code/build-pipeline
    gcloud builds submit --config=build_deploy_test.yaml --substitutions=\
    REPO_NAME=$SOURCE_CODE_REPO,\
    _DATAFLOW_JAR_BUCKET=$DATAFLOW_JAR_BUCKET_TEST,\
    _COMPOSER_INPUT_BUCKET=$INPUT_BUCKET_TEST,\
    _COMPOSER_REF_BUCKET=$REF_BUCKET_TEST,\
    _COMPOSER_DAG_BUCKET=$COMPOSER_DAG_BUCKET,\
    _COMPOSER_ENV_NAME=$COMPOSER_ENV_NAME,\
    _COMPOSER_REGION=$COMPOSER_REGION,\
    _COMPOSER_DAG_NAME_TEST=$COMPOSER_DAG_NAME_TEST
    

    Este comando instrui o Cloud Build a executar uma compilação seguindo as etapas abaixo:

    1. Crie e implante o arquivo JAR autoexecutável do WordCount.

      1. Confira o código-fonte.
      2. Compile o código-fonte do WordCount Beam em um arquivo JAR autoexecutável.
      3. Armazene o arquivo JAR no Cloud Storage onde ele pode ser selecionado pelo Cloud Composer para executar o job de processamento do WordCount.
    2. Implante e configure o fluxo de trabalho de processamento de dados no Cloud Composer.

      1. Execute o teste de unidade no código de operador personalizado usado pelo DAG do fluxo de trabalho.
      2. Implante o arquivo de entrada e o arquivo de referência de teste no Cloud Storage. O arquivo de entrada de teste é a entrada para o job de processamento do WordCount. O arquivo de referência de teste é usado como uma referência para verificar a saída do job de processamento do WordCount.
      3. Defina as variáveis do Cloud Composer para apontar para o arquivo JAR recém-criado.
      4. Implante a definição do DAG do fluxo de trabalho no ambiente do Cloud Composer.
    3. Execute o fluxo de trabalho de processamento de dados no ambiente de teste para acionar o fluxo de trabalho de processamento de teste.

Verificar o pipeline de compilação e teste

Depois de enviar o arquivo de compilação, verifique as respectivas etapas.

  1. No Console do Cloud, acesse a página Histórico da compilação para ver uma lista de todas as compilações anteriores e atuais.

    Acessar a página "Histórico da compilação"

  2. Clique na versão que está sendo executada.

  3. Na página Detalhes da compilação, verifique se as etapas de compilação correspondem às descritas anteriormente.

    Detalhes das etapas de compilação.

    Na página Detalhes da compilação, o campo Status da compilação exibe Build successful quando ela é concluída.

  4. No Cloud Shell, verifique se o arquivo JAR de amostra do WordCount foi copiado no bucket correto:

    gsutil ls gs://$DATAFLOW_JAR_BUCKET_TEST/dataflow_deployment*.jar
    

    A resposta será semelhante a:

    gs://…-composer-dataflow-source-test/dataflow_deployment_e88be61e-50a6-4aa0-beac-38d75871757e.jar
    
  5. Copie o URL da sua interface da Web do Cloud Composer e anote-o porque ele será usado na próxima etapa.

    gcloud composer environments describe $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION \
        --format="get(config.airflowUri)"
    
  6. Use o URL da etapa anterior para acessar a IU do Cloud Composer e verificar se o DAG foi executado corretamente. Se a coluna Execuções DAG não exibir informações, aguarde alguns minutos e atualize a página.

    1. Para verificar se o DAG do fluxo de trabalho de processamento de dados test_word_count foi implantado e está no modo de execução, mantenha o ponteiro sobre o círculo verde-claro abaixo de Execuções DAG e verifique se aparece Em execução.

      Status

    2. Para ver o fluxo de trabalho de processamento de dados em execução como um gráfico, clique no círculo verde-claro e, na página Execuções DAG, clique em ID do DAG: test_word_count.

    3. Atualize a página Visualização de gráfico para ver o estado da execução mais recente do DAG. Geralmente, leva de três a cinco minutos para o fluxo de trabalho ser concluído. Para verificar se a execução do DAG foi concluída com êxito, mantenha o ponteiro sobre cada tarefa para confirmar se a dica mostra Estado: sucesso. A última tarefa, chamada do_comparison, é o teste de integração que compara a saída do processo com o arquivo de referência.

Criar o pipeline de produção

Quando o fluxo de trabalho de processamento de teste é executado com êxito, é possível enviar a versão atual do fluxo de trabalho para a produção. Existem várias maneiras de implantar o fluxo de trabalho na produção:

  • Manualmente
  • Com acionamento automático quando todos os testes passam nos ambientes de teste ou de preparo
  • Com acionamento automático por um job programado

As abordagens automáticas não estão no escopo deste tutorial. Para mais informações, consulte Engenharia de lançamentos.

Neste tutorial, você fará uma implantação manual na produção executando a versão de implantação na produção do Cloud Build. Isso acontecerá em três etapas:

  1. Copie o arquivo JAR do WordCount do bucket de teste para o bucket de produção.
  2. Defina as variáveis do Cloud Composer do fluxo de trabalho de produção para apontar para o arquivo JAR recém-enviado.
  3. Implante a definição do DAG do fluxo de trabalho de produção no ambiente do Cloud Composer e execute o fluxo.

As substituições variáveis definem o nome do arquivo JAR mais recente que é implantado na produção com os buckets do Cloud Storage usados pelo fluxo de trabalho de processamento de produção. Para criar o pipeline do Cloud Build que implanta o fluxo de trabalho do Airflow na produção, faça o seguinte:

  1. No Cloud Shell, leia o nome do arquivo JAR mais recente imprimindo a variável do Cloud Composer para o nome de arquivo JAR:

    export DATAFLOW_JAR_FILE_LATEST=$(gcloud composer environments run $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION variables -- \
        --get dataflow_jar_file_test 2>&1 | grep -i '.jar')
    
  2. Use o arquivo de configuração do pipeline de compilação deploy_prod.yaml, para criar o pipeline no Cloud Build:

    cd ~/ci-cd-for-data-processing-workflow/source-code/build-pipeline
    gcloud builds submit --config=deploy_prod.yaml --substitutions=\
    REPO_NAME=$SOURCE_CODE_REPO,\
    _DATAFLOW_JAR_BUCKET_TEST=$DATAFLOW_JAR_BUCKET_TEST,\
    _DATAFLOW_JAR_FILE_LATEST=$DATAFLOW_JAR_FILE_LATEST,\
    _DATAFLOW_JAR_BUCKET_PROD=$DATAFLOW_JAR_BUCKET_PROD,\
    _COMPOSER_INPUT_BUCKET=$INPUT_BUCKET_PROD,\
    _COMPOSER_ENV_NAME=$COMPOSER_ENV_NAME,\
    _COMPOSER_REGION=$COMPOSER_REGION,\
    _COMPOSER_DAG_BUCKET=$COMPOSER_DAG_BUCKET,\
    _COMPOSER_DAG_NAME_PROD=$COMPOSER_DAG_NAME_PROD
    

Verificar o fluxo de trabalho de processamento de dados criado pelo pipeline de produção

  1. Copie o URL da sua IU do Cloud Composer:

    gcloud composer environments describe $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION \
        --format="get(config.airflowUri)"
    
  2. Para verificar se o DAG do fluxo de trabalho de processamento de dados de produção foi implantado, acesse o URL que você recuperou na etapa anterior e verifique se o DAG prod_word_count está na lista de DAGs.

    1. Na página DAGs, na linha prod_word_count, clique em Acionar DAG.

      Ícone

    2. Na caixa de diálogo Confirmação, clique em Confirmar.

  3. Recarregue a página para atualizar o status de execução do DAG. Para verificar se o DAG do fluxo de trabalho de processamento de dados de produção foi implantado e está no modo de execução, mantenha o ponteiro sobre o círculo verde-claro abaixo de Execuções DAG e veja se aparece Em execução.

    Status

  4. Após a conclusão da execução, mantenha o ponteiro sobre o círculo verde-escuro abaixo da coluna Execuções DAG e veja se aparece Sucesso.

    Status

  5. No Cloud Shell, liste os arquivos de resultados no bucket do Cloud Storage:

    gsutil ls gs://$RESULT_BUCKET_PROD
    

    A resposta será semelhante a esta:

    gs://…-composer-result-prod/output-00000-of-00003
    gs://…-composer-result-prod/output-00001-of-00003
    gs://…-composer-result-prod/output-00002-of-00003
    

Como configurar um gatilho de compilação

É preciso configurar um gatilho do Cloud Build que aciona uma nova compilação quando as alterações são enviadas para a ramificação mestre do repositório de origem.

  1. No Cloud Shell, execute o seguinte comando para visualizar todas as variáveis de substituição necessárias para a compilação. Anote esses valores, porque eles serão necessários em uma etapa posterior.

    echo "_DATAFLOW_JAR_BUCKET : ${DATAFLOW_JAR_BUCKET_TEST}
    _COMPOSER_INPUT_BUCKET : ${INPUT_BUCKET_TEST}
    _COMPOSER_REF_BUCKET : ${REF_BUCKET_TEST}
    _COMPOSER_DAG_BUCKET : ${COMPOSER_DAG_BUCKET}
    _COMPOSER_ENV_NAME : ${COMPOSER_ENV_NAME}
    _COMPOSER_REGION : ${COMPOSER_REGION}
    _COMPOSER_DAG_NAME_TEST : ${COMPOSER_DAG_NAME_TEST}"
    
  2. No Console do Cloud, acesse a página Gatilhos de compilação.

    Acessar a página "Gatilhos de compilação"

  3. Clique em Criar acionador.

  4. Clique em Cloud Source Repository e em Continuar.

  5. Clique em data-pipeline-source e em Continuar.

  6. Para definir as configurações do gatilho, siga estas etapas:

    • No campo Nome, insira Trigger build in test environment.
    • Em Tipo de gatilho, clique em Ramificação.
    • No campo Ramificação (regex), insira master.
    • Em Configuração da compilação, clique em Arquivo de configuração do Cloud Build (yaml ou json).
    • No campo Local do arquivo de configuração do Cloud Build, insira build-pipeline/build_deploy_test.yaml.
  7. Na página Configurações do gatilho, substitua as variáveis pelos valores do seu ambiente gerados na etapa anterior. Adicione os itens abaixo um por um e clique em + Adicionar item para cada um dos pares de nome-valor.

    • _DATAFLOW_JAR_BUCKET
    • _COMPOSER_INPUT_BUCKET
    • _COMPOSER_REF_BUCKET
    • _COMPOSER_DAG_BUCKET
    • _COMPOSER_ENV_NAME
    • _COMPOSER_REGION
    • _COMPOSER_DAG_NAME_TEST

      Mapeamento de pares de nome-valor.

  8. Clique em Criar gatilho.

Testar o acionador

Para testar o acionador, é preciso adicionar uma nova palavra ao arquivo de entrada de teste e fazer o ajuste correspondente no arquivo de referência de teste. Depois, verifique se o pipeline de compilação é acionado por um envio de confirmação para o Cloud Source Repositories e se o fluxo de trabalho de processamento de dados é executado corretamente com os arquivos de teste atualizados.

  1. No Cloud Shell, adicione uma palavra de teste ao fim do arquivo:

    echo "testword" >>  ~/$SOURCE_CODE_REPO/workflow-dag/support-files/input.txt
    
  2. Atualize o arquivo de referência de resultados do teste, ref.txt, para corresponder às alterações feitas no arquivo de entrada de teste:

    echo "testword: 1" >>  ~/$SOURCE_CODE_REPO/workflow-dag/support-files/ref.txt
    
  3. Confirme e envie as alterações ao Cloud Source Repositories:

    cd ~/$SOURCE_CODE_REPO
    git add .
    git commit -m 'change in test files'
    git push google master
    
  4. No Console do Cloud, acesse a página Histórico.

    ACESSAR PÁGINA "HISTÓRICO"

  5. Para verificar se uma nova compilação é acionada pelo envio anterior para o branch mestre, confirme se a coluna Acionador mostra Enviar para branch mestre na compilação em execução.

  6. No Cloud Shell, copie o URL da interface da Web do Cloud Composer:

    gcloud composer environments describe $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION --format="get(config.airflowUri)"
    
  7. Após a conclusão da compilação, acesse o URL do comando anterior para verificar se o DAG test_word_count está em execução.

    Aguarde até que a execução do DAG seja concluída, o que é indicado quando o círculo verde-claro desaparece da coluna Execuções DAG. Geralmente, o processo leva de três a cinco minutos.

  8. No Cloud Shell, faça o download dos arquivos de resultados de teste:

    mkdir ~/result-download
    cd ~/result-download
    gsutil cp gs://$RESULT_BUCKET_TEST/output* .
    
  9. Verifique se a palavra recém-adicionada está em um dos arquivos de resultado:

    grep testword output*
    

    A resposta será semelhante a:

    output-00000-of-00003:testword: 1
    

Como fazer a limpeza

Para evitar que os recursos usados neste tutorial sejam cobrados na conta do Google Cloud Platform, faça o seguinte:

Excluir o projeto

  1. No Console do Cloud, acesse a página Gerenciar recursos:

    Acessar a página "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Excluir os recursos individuais

Se você quiser manter o projeto usado para este tutorial, exclua os recursos criados da seguinte forma:

  1. Para excluir o gatilho do Cloud Build, siga estas etapas:

    1. No Console do Cloud, acesse a página Gatilhos.

      Acessar a página "Gatilhos"

    2. Ao lado do gatilho que você criou, clique em Mais e em Excluir.

  2. Exclua o ambiente do Cloud Composer no Cloud Shell:

    gcloud -q composer environments delete $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION
    
  3. Exclua os buckets do Cloud Storage e os arquivos deles:

    gsutil -m rm -r gs://$DATAFLOW_JAR_BUCKET_TEST \
        gs://$INPUT_BUCKET_TEST \
        gs://$REF_BUCKET_TEST \
        gs://$RESULT_BUCKET_TEST \
        gs://$DATAFLOW_STAGING_BUCKET_TEST \
        gs://$DATAFLOW_JAR_BUCKET_PROD \
        gs://$INPUT_BUCKET_PROD \
        gs://$RESULT_BUCKET_PROD \
        gs://$DATAFLOW_STAGING_BUCKET_PROD
    
  4. Exclua o repositório:

    gcloud -q source repos delete $SOURCE_CODE_REPO
    
  5. Exclua os arquivos e a pasta que você criou:

    rm -rf ~/ci-cd-for-data-processing-workflow
    rm -rf ~/$SOURCE_CODE_REPO
    rm -rf ~/result-download
    

A seguir