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.
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.
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.
- A pasta
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:
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
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.
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.
- Em ID do tópico, insira
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:
Crie e implante o arquivo JAR autoexecutável do WordCount.
- Confira o código-fonte.
- Compile o código-fonte do WordCount Beam em um arquivo JAR autoexecutável.
- Armazene o arquivo JAR no Cloud Storage onde ele pode ser selecionado pelo Cloud Composer para executar o job de processamento do WordCount.
Implante e configure o fluxo de trabalho de processamento de dados no Cloud Composer.
- Execute o teste de unidade no código de operador personalizado usado pelo DAG do fluxo de trabalho.
- 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.
- Defina as variáveis do Cloud Composer para apontar para o arquivo JAR recém-criado.
- Implante a definição do DAG do fluxo de trabalho no ambiente do Cloud Composer.
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.
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.
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.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
.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ópicointegration-test-complete-topic
do Pub/Sub que será usada para acionar o pipeline do build de produção.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
.No Console do Google Cloud, acesse a página Assinaturas.
Clique em integration-test-complete-topic-sub, selecione a guia Mensagem e clique em Pull
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.- Na página DAGs, na linha
prod_word_count
, clique em Acionar DAG.
- Na página DAGs, na linha
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.
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 campo Nome, use
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.
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
.
- No campo Nome, use
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}"
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.
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.
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.
- No Console do Google Cloud, acesse a página 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:
No Console do Google Cloud, acesse a página Gatilhos.
Ao lado dos gatilhos que você criou, clique em Maismore_vert 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.