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 Platform (GCP). 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ê usará os seguintes produtos do GCP:

  • 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 sua compilação no GCP. Uma compilação é uma série de etapas de desenvolvimento, 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 e testar e verificar os resultados. O Cloud Composer é um serviço gerenciado do Apache Airflow (em inglês), que oferece um ambiente onde é possível criar, programar, monitorar e gerenciar fluxos de trabalho complexos, como de processamento de dados mostrado neste tutorial.
  • O Cloud Dataflow para executar o exemplo do Apache Beam WordCount (em inglês) 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 seleciona o arquivo JAR e executa o job de processamento de dados no Cloud 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 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 intervalo do JAR de teste no Cloud Storage.
  4. O Cloud Build implanta os arquivos de teste nos intervalos 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 intervalo 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 intervalo do JAR de teste para o intervalo 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 intervalo 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 intervalos 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, não abordaremos esse método aqui. Para mais informações sobre como acessar recursos em vários projetos do GCP, 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 é 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. Execute o processo de dados do WordCount no Cloud Dataflow.
  2. Faça o download dos arquivos de saída do processo do WordCount, que abrangem os seguintes:

    • download_result_1
    • download_result_2
    • download_result_3
  3. Faça o download do arquivo de referência, chamado download_ref_string.

  4. Verifique o resultado em relação ao 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 intervalos 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, os seguintes componentes faturáveis do Google Cloud Platform são usados:

Use a calculadora de preços para gerar uma estimativa de custo com base no uso do projeto. Novos usuários do GCP são 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. Selecione ou crie um projeto do GCP.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado para o projeto.

    Saiba como ativar o faturamento

  4. Ativar Cloud Build, Cloud Source Repositories, Cloud Composer e Cloud Dataflow APIs.

    Ativar 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 GCP.
  • A pasta source-code contém um código desenvolvido ao longo do tempo, tem fontes controladas e aciona 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 Composer para os fluxos de trabalho de processamento de dados com etapas de desenvolvimento, implementação e teste do processo do Cloud Dataflow.
    • A pasta build-pipeline contém duas configurações de Cloud Build, uma para o pipeline de teste e outra para o pipeline de produção. Ela também contém 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, que aparece como uma janela na parte inferior do Console do Google Cloud Platform.

  1. No Console do GCP, 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:

    • Seu código de projeto do GCP
    • Sua região e zona
    • O nome dos intervalos 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ê criará um ambiente do Cloud Composer que consiste nos nós g1-small.

  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 g1-small \
        --node-count 3 \
        --disk-size 20
    
  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:

    • Seu código de projeto do GCP
    • Sua região e zona
    • O nome dos intervalos 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 intervalo do Cloud Storage para armazenar os DAGs. Quando você move um arquivo de definição do DAG para o intervalo, o Cloud Composer lê automaticamente os arquivos. O intervalo 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 intervalos e configure o pipeline de CI/CD para implantar automaticamente as definições do DAG no intervalo do Cloud Storage.

  1. No Cloud Shell, exporte o URL do intervalo 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 intervalos do Cloud Storage:

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

Criar os intervalos do Cloud Storage

Nesta seção, você cria um conjunto de intervalos 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 Cloud Dataflow para armazenar os arquivos binários

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

  • No Cloud Shell, crie intervalos 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 no Cloud Composer, consulte a documentação de controle de acesso desse recurso.

  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 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 acione 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 configuradas no arquivo de configuração YAML. Neste tutorial, você usará as imagens de construtor predefinidas para git, maven, gsutil e gcloud de forma a 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 criação. Os locais do repositório do código-fonte e dos intervalos 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 GCP, acesse a página Histórico de versões para visualizar uma lista de todas as versões anteriores e em execução atualmente.

    Acessar a página "Histórico de versões"

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

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

    Detalhes das etapas de compilação.

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

  4. No Cloud Shell, verifique se o arquivo JAR de exemplo do WordCount foi copiado no intervalo 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 do DAG não exibir qualquer informação, aguarde alguns minutos e recarregue a página.

    1. Para verificar se o test_word_count do DAG do fluxo de trabalho de processamento de dados foi implantado e está em execução, mantenha o cursor no círculo verde abaixo de Execuções do DAG e verifique se ele mostra Em execução.

      Status "Em execução" do processamento de 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 do DAG, clique em Código do DAG: test_word_count.

    3. Recarregue a página Visualização de gráfico para atualizar o estado da execução atual 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 cursor sobre cada tarefa para verificar se a dica mostra Estado: sucesso. A última tarefa, denominada do_comparison, é o teste de integração que compara a saída do processo e 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 agendado

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 intervalo de teste para o intervalo 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 intervalos 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 do 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 >/dev/null | 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 está implantado, acesse o URL recuperado na etapa anterior e verifique se o DAG prod_word_count está na lista.

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

      Ícone "Reproduzir" para acionar o DAG.

    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 cursor sobre o círculo verde-claro abaixo de Execuções do DAG e veja se ele mostra Em execução.

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

  4. Após de a execução ser concluída, mantenha o cursor sobre o círculo verde escuro abaixo da coluna Execuções do DAG e confirme se ele mostra Sucesso.

    Status "Sucesso" na coluna "Execuções do DAG".

  5. No Cloud Shell, liste os arquivos de resultados no intervalo 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
    

Configurar um acionador de compilação

É preciso configurar um acionador do Cloud Build que inicializa uma nova compilação quando as alterações são enviadas para o branch 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 GCP, acesse a página Acionadores de versão.

    Acessar a página "Acionadores de versã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 acionador, faça o seguinte:

    • No campo Nome, digite Trigger build in test environment.
    • Em Tipo de acionador, clique em Branch.
    • No campo Branch (regex), insira master.
    • Em Configuração de 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, digite build-pipeline/build_deploy_test.yaml.
  7. Na página Configurações de acionador, substitua as variáveis pelos valores do seu ambiente geradas 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 acionador.

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 no final do arquivo:

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

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

    cd ~/$SOURCE_CODE_REPO
    git add .
    git commit -m 'change in test files'
    git push google master
    
  4. No Console do GCP, 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 do 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, é possível fazer o seguinte:

Excluir o projeto

  1. No Console do GCP, acesse a página "Projetos".

    Acessar a página Projetos

  2. Na lista de projetos, selecione um e clique em Excluir projeto.
  3. Na caixa de diálogo, digite o código do projeto e clique em Encerrar para excluí-lo.

Excluir recursos individuais

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

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

    1. No Console do GCP, acesse a página Acionadores.

      Acessar a página "Acionadores"

    2. Ao lado do acionador 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 intervalos 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
    

Próximas etapas

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…