Implantar um pipeline de CI/CD para fluxos de trabalho de processamento de dados

Last reviewed 2023-05-12 UTC

Neste documento, descrevemos como implantar a arquitetura em Usar um pipeline de CI/CD para fluxos de trabalho de processamento de dados.

Esta implantação 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) para sistematizar e automatizar as cargas de trabalho.

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ões 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

Arquitetura

O diagrama a seguir mostra uma visualização detalhada das etapas do pipeline de CI/CD para o pipeline de teste e o pipeline de produção.

Diagrama arquitetônico do pipeline de CI/CD.

No diagrama anterior, o pipeline de teste começa quando um desenvolvedor confirma alterações de código no Cloud Source Repositories e termina quando o teste de integração do fluxo de trabalho de processamento de dados é aprovado. Nesse ponto, o pipeline publica uma mensagem no Pub/Sub que contém uma referência ao arquivo Java (JAR) autoexecutável mais recente (recebido das variáveis do Airflow) no campo de dados da mensagem.

No diagrama anterior, o pipeline de produção começa quando uma mensagem é publicada em um tópico do Pub/Sub e termina quando o arquivo DAG do fluxo de trabalho de produção é implantado no Cloud Composer.

Nesta implantação, 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 que oferece um ambiente onde é possível criar, programar, monitorar e gerenciar fluxos de trabalho complexos, como o de processamento de dados mostrado nesta implantação.
O Dataflow para executar o exemplo WordCount (em inglês) do Apache Beam como um processo de dados de amostra.

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.

Otimização de custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Antes de começar

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

Observação: se você não pretende manter os recursos criados nesta implantação, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir a implantação, exclua o projeto para remover todos os recursos associados a ele.

Acessar o seletor de projetos
Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como verificar se o faturamento está ativado em um projeto.

Código de amostra

O código de amostra desta implantação está 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.

Para essa implantação, os arquivos de código-fonte para o processamento de dados e para o fluxo de trabalho do DAG estão em pastas diferentes no mesmo repositório de código-fonte. 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.

Testes de integração e unidade

Além do teste de integração que verifica todo o fluxo de trabalho de processamento de dados, esta implantação 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.

Configure seu ambiente

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

No Console do Google Cloud, abra o Cloud Shell:

Abra o Cloud Shell

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

git clone https://github.com/GoogleCloudPlatform/ci-cd-for-data-processing-workflow.git

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.
Como as variáveis de ambiente não são retidas entre as sessões, se a sessão do Cloud Shell for encerrada ou desconectada enquanto você estiver trabalhando durante essa implantação, será necessário redefinir as variáveis de ambiente.

Criar o ambiente do Cloud Composer

Nesta implantação, você configura um ambiente do Cloud Composer.

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

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
```
Observação: geralmente, leva cerca de 15 minutos para provisionar o ambiente do Cloud Composer, mas pode levar até uma hora. Aguarde a conclusão do processo antes de continuar.
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.

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)")

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

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

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

Acesse a página "Tópicos"
Clique em Criar tópico.
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 outras opções em branco.
- Em Criptografia, selecione Chave de criptografia gerenciada pelo Google.
- Clique em Criar tópico.

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

Nesta implantação, você tem uma base de código de origem que precisa ser colocada 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.

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

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. Nesta implantação, você usará imagens do builder predefinidas para git, maven, gsutil e gcloud a fim de executar as tarefas em cada etapa de build. As substituições de variáveis de configuração serão usadas para definir as configurações do ambiente no momento da compilação. O local do repositório de código-fonte é definido por substituições de variáveis e os locais dos buckets do Cloud Storage. 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. Para acionar o fluxo de trabalho de processamento de testes, execute o fluxo de trabalho de processamento de dados no ambiente de teste.

Verificar o pipeline de compilação e teste

Depois de enviar o arquivo de compilação, verifique as etapas abaixo:

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"
Clique na versão que está sendo executada.
Na página Detalhes da compilação, verifique se as etapas de compilação correspondem às descritas anteriormente.

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

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

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)"

Use o URL da etapa anterior para acessar a interface 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 recarregue 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 em Execuções e verifique se aparece Em execução.
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 3 a 5 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.
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:

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.

Nesta implantação, 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:

Copie o arquivo JAR do WordCount do bucket de teste para o bucket de produção.
Defina as variáveis do Cloud Composer do fluxo de trabalho de produção para apontar para o arquivo JAR recém-enviado.
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:

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')

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

Copie o URL da sua IU do Cloud Composer:

gcloud composer environments describe $COMPOSER_ENV_NAME \
    --location $COMPOSER_REGION \
    --format="get(config.airflowUri)"

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.
Para atualizar o status de execução do DAG, clique no logotipo do Airflow ou atualize a página. Um círculo verde-claro na coluna Execuções indica que o DAG está em execução.
Após a conclusão da execução, mantenha o ponteiro sobre o círculo verde-escuro ao lado da coluna Execuções DAG e veja se aparece Sucesso.

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

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.

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

Acessar a página "Gatilhos de versão"
Clique em Criar gatilho.
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.

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}"

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
Clique em Criar.

Configurar o gatilho do pipeline de build 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.

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

Acessar a página "Gatilhos de versão"
Clique em Criar gatilho.
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.

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}"

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)
Em Aprovação, selecione Exigir aprovação antes da execução do build.
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.

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

echo "testword" >>  ~/$SOURCE_CODE_REPO/workflow-dag/support-files/input.txt

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

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

No console do Google Cloud, abra a página IAM.

ACESSAR PÁGINA "HISTÓRICO"
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.

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)"

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. Normalmente, o processo leva de três a cinco minutos.

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

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

Acessar a página de histórico
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.
Para executar o pipeline de build de produção, marque a caixa de seleção ao lado da versão, clique em Aprovar e, depois, em Aprovar na caixa de confirmação.
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.

Limpeza

Nas seções a seguir, explicamos como evitar cobranças futuras pelo projeto do Google Cloud e pelos recursos do Apache Hive e do Dataproc usados nessa implantação.

Excluir o projeto do Google Cloud

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados nessa implantação, exclua o projeto do Google Cloud.

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

No Console do Google Cloud, acesse a página Gerenciar recursos.
Acessar "Gerenciar recursos"
Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Excluir recursos individuais

Se você quiser manter o projeto usado para essa implantação, execute as etapas a seguir para excluir os recursos criados.

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.

Exclua o ambiente do Cloud Composer no Cloud Shell:

gcloud -q composer environments delete $COMPOSER_ENV_NAME \
    --location $COMPOSER_REGION

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

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

Exclua o repositório:

gcloud -q source repos delete $SOURCE_CODE_REPO

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

Saiba mais sobre Entrega contínua no estilo GitOps com o Cloud Build.
Saiba como usar um pipeline de CI/CD para fluxos de trabalho de processamento de dados.
Saiba mais sobre os padrões comuns de casos de uso do Dataflow (em inglês).
Saiba mais sobre engenharia de lançamento.
Para mais arquiteturas de referência, diagramas e práticas recomendadas, confira a Central de arquitetura do Cloud.