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

Last reviewed 2023-04-20 UTC

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 processamento de dados e o fluxo de trabalho dele. 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

Em um nível mais detalhado, 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 chamar o arquivo JAR recém-implantado.
  6. O Cloud Build testa o fluxo de trabalho Directed Acyclic Graph (DAG) (em inglês) do 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.
  9. Quando o teste de integração do fluxo de trabalho de processamento de dados é aprovado, uma mensagem é publicada no Pub/Sub que contém uma referência ao JAR de execução automática mais recente (recebido das variáveis do Airflow) no campo de dados da mensagem.

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

  1. O pipeline de implantação de produção é acionado quando uma mensagem é publicada em um tópico do Pub/Sub.
  2. Um desenvolvedor aprova manualmente o pipeline de implantação da produção e o build é executado.
  3. 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.
  4. 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.
  5. 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 sobre 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.

  5. Publique uma mensagem no Pub/Sub depois que o teste de integração for aprovado.

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 documento, você usará 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 estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

  1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
  2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

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

    Ative as APIs

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

    Acessar o seletor de projetos

  6. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  7. 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.

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 Google Cloud, abra o Cloud Shell:

    Abra o Cloud Shell

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

    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.

Criar o ambiente do Cloud Composer

Neste tutorial, você configura um ambiente do Cloud Composer.

  1. No Cloud Shell, adicione o papel Extensão de agente de serviço da API Cloud Composer v2 (roles/composer.ServiceAgentV2Ext) à conta do agente de serviço do Cloud Composer:

    gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
        --member serviceAccount:service-$PROJECT_NUMBER@cloudcomposer-accounts.iam.gserviceaccount.com \
        --role roles/composer.ServiceAgentV2Ext
    
  2. Crie o ambiente do Cloud Composer no Cloud Shell:

    gcloud composer environments create $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION \
        --image-version composer-2.0.14-airflow-2.2.5
    
  3. 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
    

Como criar o tópico do Pub/Sub

Nesta seção, você cria um tópico do Pub/Sub para receber mensagens enviadas do teste de integração do fluxo de trabalho de processamento de dados para acionar automaticamente o pipeline do build de produção.

  1. No Console do Google Cloud, acesse a página Tópicos do Pub/Sub.

    Acesse a página "Tópicos"

  2. Clique em Criar tópico.

  3. Para configurar o tópico, siga estas etapas:

    • Em ID do tópico, insira integration-test-complete-topic.
    • Confirme se a opção Adicionar uma assinatura padrão está marcada.
    • Deixe as opções restantes desmarcadas.
    • Em Criptografia, selecione Chave de criptografia gerenciada pelo Google.
    • Clique em Criar tópico.

    Criar tópico do Pub/Sub.

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 etapas abaixo:

  1. No Console do Google 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
    

    O resultado será assim:

    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 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 e verifique se aparece Em execução.

      Status "Em execução" do processamento do DAG.

    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 penúltima tarefa, chamada do_comparison, é o teste de integração que verifica a saída do processo em relação ao arquivo de referência.

  7. Quando o teste de integração for concluído, a última tarefa, denominada publish_test_complete, publicará uma mensagem no tópico integration-test-complete-topic do Pub/Sub que será usada para acionar o pipeline do build de produção.

    1. Para verificar se a mensagem publicada contém a referência correta ao arquivo JAR mais recente, podemos extrair a mensagem da assinatura padrão do Pub/Sub integration-test-complete-topic-sub.

    2. No Console do Google Cloud, acesse a página Assinaturas.

      Acesse a página "Assinaturas"

    3. Clique em integration-test-complete-topic-sub, selecione a guia Mensagem e clique em Pull

    4. A saída será semelhante a esta:

      Mensagem de teste concluída.

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.

Neste tutorial, o build de produção será acionado automaticamente quando todos os testes forem aprovados no ambiente de teste. Para mais informações sobre abordagens automatizadas, consulte Engenharia de versões.

Antes de implementar a abordagem automatizada, verifique o build da implantação de produção fazendo uma implantação manual na produção. 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 "Play" para acionar o DAG.

  3. Clique no logotipo do Airflow ou atualize a página para atualizar o status de execução do DAG. Um círculo verde-claro na coluna Execuções indica que o DAG está em execução. Mantenha o ponteiro no círculo para ver a dica: Em execução.

    Status "Em execução" na coluna "Execuções DAG".

  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 "Sucesso" na coluna "Execuções DAG".

  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 criar gatilhos do Cloud Build

Nesta seção, você vai criar gatilhos do Cloud Build que vinculam as mudanças do código-fonte ao processo de compilação do teste e entre os pipelines de teste e de produção.

Configure o gatilho de pipeline de compilação do teste

É 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 console do Google Cloud, acesse a página Gatilhos de compilação.

    Acessar a página "Gatilhos de versão"

  2. Clique em Criar gatilho.

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

    • No campo Nome, use trigger-build-in-test-environment.
    • No menu suspenso Região, selecione global (não regional).
    • Em Evento, clique em Mover para uma ramificação.
    • Em Origem, selecione data-pipeline-source.
    • No campo Nome da ramificação, insira master.
    • Em Configuração, clique em Arquivo de configuração do Cloud Build (yaml ou json).
    • Em Local, clique em Repositório.
    • No campo Local do arquivo de configuração do Cloud Build, insira build-pipeline/build_deploy_test.yaml.
  4. 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 "_COMPOSER_DAG_BUCKET : ${COMPOSER_DAG_BUCKET}
    _COMPOSER_DAG_NAME_TEST : ${COMPOSER_DAG_NAME_TEST}
    _COMPOSER_ENV_NAME : ${COMPOSER_ENV_NAME}
    _COMPOSER_INPUT_BUCKET : ${INPUT_BUCKET_TEST}
    _COMPOSER_REF_BUCKET : ${REF_BUCKET_TEST}
    _COMPOSER_REGION : ${COMPOSER_REGION}
    _DATAFLOW_JAR_BUCKET : ${DATAFLOW_JAR_BUCKET_TEST}"
    

    Observação: o par de nome/valor de saída é usado na próxima etapa

  5. Na página Configurações do gatilho, em Variáveis avançadas e de substituição, 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.

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

      Mapeamento de pares de nome-valor.

  6. Clique em Criar.

Como configurar o gatilho de pipeline de compilação de produção

Configure um gatilho do Cloud Build que aciona um build de produção quando os testes são aprovados no ambiente de teste e uma mensagem é publicada no tópico do Pub/Sub tests-complete. Esse gatilho inclui uma etapa de aprovação em que o build precisa ser aprovado manualmente antes da execução do pipeline de produção.

  1. No console do Google Cloud, acesse a página Gatilhos de compilação.

    Acessar a página "Gatilhos de versão"

  2. Clique em Criar gatilho.

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

    • No campo Nome, use trigger-build-in-prod-environment.
    • No menu suspenso Região, selecione global (não regional).
    • Em Evento, clique em Mensagem do Pub/Sub.
    • Em Assinatura, selecione integration-test-complete-topic.
    • Em Origem, selecione data-pipeline-source.
    • Em Revisão, selecione Ramificação.
    • No campo Nome da ramificação, insira master.
    • Em Configuração, clique em Arquivo de configuração do Cloud Build (yaml ou json).
    • Em Local, clique em Repositório.
    • No campo Local do arquivo de configuração do Cloud Build, insira build-pipeline/deploy_prod.yaml.
  4. 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 "_COMPOSER_DAG_BUCKET : ${COMPOSER_DAG_BUCKET}
    _COMPOSER_DAG_NAME_PROD : ${COMPOSER_DAG_NAME_PROD}
    _COMPOSER_ENV_NAME : ${COMPOSER_ENV_NAME}
    _COMPOSER_INPUT_BUCKET : ${INPUT_BUCKET_PROD}
    _COMPOSER_REGION : ${COMPOSER_REGION}
    _DATAFLOW_JAR_BUCKET_PROD : ${DATAFLOW_JAR_BUCKET_PROD}
    _DATAFLOW_JAR_BUCKET_TEST : ${DATAFLOW_JAR_BUCKET_TEST}"
    

    Observação: o par de nome/valor de saída é usado na próxima etapa

  5. Na página Configurações do gatilho, em Variáveis avançadas e de substituição, 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.

    • _COMPOSER_DAG_BUCKET
    • _COMPOSER_DAG_NAME_PROD
    • _COMPOSER_ENV_NAME
    • _COMPOSER_INPUT_BUCKET
    • _COMPOSER_REGION
    • _DATAFLOW_JAR_BUCKET_PROD
    • _DATAFLOW_JAR_BUCKET_TEST
    • _DATAFLOW_JAR_FILE_LATEST = $(body.message.data)

      Mapeamento de pares de nome-valor.

  6. Em Aprovação, marque Exigir aprovação antes da execução do build.

  7. Clique em Criar.

Teste os gatilhos

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 Google Cloud, abra a página IAM.

    ACESSAR PÁGINA "HISTÓRICO"

  5. Para verificar se um novo build de teste é acionado pelo envio anterior para a ramificação principal, no build em execução atual, a coluna Ref diz master.

  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*
    

    O resultado será assim:

    output-00000-of-00003:testword: 1
    
  10. No console do Google Cloud, abra a página IAM.

    Acessar a página de histórico

  11. Verifique se um novo build de produção foi acionado pela conclusão do teste de integração e se o build está aguardando aprovação.

    Build de produção acionado.

  12. Marque a caixa ao lado do build, clique em Aprovar e em Aprovar na caixa de confirmação para executar o pipeline de compilação de produção.

  13. Após a conclusão da compilação, acesse o URL do comando anterior e acione o DAG prod_word_count manualmente para executar o pipeline de produção.

    Ícone "Play" para acionar o DAG.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Exclua o projeto

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

    Acessar "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 Google Cloud, acesse a página Gatilhos.

      Acessar a página "Gatilhos"

    2. Ao lado dos gatilhos 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. Para excluir o tópico do Pub/Sub e a assinatura padrão, execute os seguintes comandos no Cloud Shell:

    gcloud pubsub topics delete integration-test-complete-topic
    gcloud pubsub subscriptions delete integration-test-complete-topic-sub
    
  5. Exclua o repositório:

    gcloud -q source repos delete $SOURCE_CODE_REPO
    
  6. 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
    

Próximas etapas