Visão geral

Neste laboratório, você vai:

• converter um pipeline personalizado em um modelo flexível personalizado do Dataflow;
• executar um modelo Flex do Dataflow.

Pré-requisitos:

• Noções básicas sobre o Python

Um pipeline que aceita parâmetros de linha de comando é muito mais útil do que um com parâmetros codificados. No entanto, executar esse tipo de pipeline exige a criação de um ambiente de desenvolvimento. Usar um modelo do Dataflow é uma opção ainda melhor para pipelines que serão executados novamente por vários usuários ou em contextos distintos.

Existem muitos modelos do Dataflow que já foram criados como parte do Google Cloud Platform. Para saber mais, conheça o guia Introdução aos modelos fornecidos pelo Google. No entanto, nenhum deles executa a mesma função que o pipeline deste laboratório. Em vez disso, nesta etapa você vai converter o pipeline em um modelo Flex do Dataflow novo e personalizado, e não em um modelo tradicional e personalizado.

Converter um pipeline em um modelo Flex personalizado do Dataflow exige o uso de um contêiner do Docker para empacotar o código e as dependências, um Dockerfile para descrever qual código deve ser criado, o Cloud Build para gerar o contêiner subjacente que será executado no ambiente de execução para criar o job real e, por fim, um arquivo de metadados para descrever os parâmetros do job.

Configuração e requisitos

Configuração do laboratório

Para cada laboratório, você recebe um novo projeto do Google Cloud e um conjunto de recursos por um determinado período e sem custos financeiros.

1. Faça login no Qwiklabs em uma janela anônima.

2. Confira o tempo de acesso do laboratório (por exemplo, 1:15:00) e finalize todas as atividades nesse prazo.
   Não é possível pausar o laboratório. Você pode reiniciar o desafio, mas vai precisar refazer todas as etapas.

3. Quando tudo estiver pronto, clique em Começar o laboratório.

4. Anote as credenciais (Nome de usuário e Senha). É com elas que você vai fazer login no Console do Google Cloud.

5. Clique em Abrir Console do Google.

6. Clique em Usar outra conta, depois copie e cole as credenciais deste laboratório nos locais indicados.
   Se você usar outras credenciais, vai receber mensagens de erro ou cobranças.

7. Aceite os termos e pule a página de recursos de recuperação.

Verifique as permissões do projeto

Antes de começar a trabalhar no Google Cloud, veja se o projeto tem as permissões corretas no Identity and Access Management (IAM).

1. No console do Google Cloud, em Menu de navegação (), selecione IAM e administrador > IAM.

2. Confira se a conta de serviço padrão do Compute {project-number}-compute@developer.gserviceaccount.com está na lista e recebeu o papel de editor. O prefixo da conta é o número do projeto, que está no Menu de navegação > Visão geral do Cloud > Painel.

Observação: se a conta não estiver no IAM ou não tiver o papel de editor, siga as etapas abaixo.

1. No console do Google Cloud, em Menu de navegação, clique em Visão geral do Cloud > Painel.
2. Copie o número do projeto, por exemplo, 729328892908.
3. Em Menu de navegação, clique em IAM e administrador > IAM.
4. Clique em Permitir acesso, logo abaixo de Visualizar por principais na parte de cima da tabela de papéis.
5. Em Novos principais, digite:

{número-do-projeto}-compute@developer.gserviceaccount.com

6. Substitua {project-number} pelo número do seu projeto.
7. Em Papel, selecione Projeto (ou Básico) > Editor.
8. Clique em Save.

Configuração do ambiente de desenvolvimento baseado em notebook do Jupyter

Neste laboratório, você vai executar todos os comandos em um terminal usando seu notebook.

1. No Menu de navegação do console do Google Cloud, clique em Vertex AI > Workbench.

2. Selecione Ativar a API Notebooks.

3. Na página "Workbench", selecione NOTEBOOKS GERENCIADOS PELO USUÁRIO e clique em CRIAR NOVO.

4. Na caixa de diálogo Nova instância, defina a região como e a zona como .

5. Em "Ambiente", selecione Apache Beam.

6. Clique em CRIAR na parte de baixo da caixa de diálogo.

Observação: pode levar de três a cinco minutos para que o ambiente seja totalmente provisionado. Aguarde até a conclusão dessa etapa. Observação: clique em Ativar API Notebooks para fazer isso.

7. Depois, clique no link ABRIR O JUPYTERLAB ao lado do nome do seu notebook para abrir o ambiente em uma nova guia do seu navegador.

8. Em seguida, clique em Terminal. Nele, é possível executar todos os comandos deste laboratório.

Faça o download do repositório de código

Agora você precisa dele para usar neste laboratório.

1. Insira este comando no terminal que você abriu:

git clone https://github.com/GoogleCloudPlatform/training-data-analyst cd /home/jupyter/training-data-analyst/quests/dataflow_python/

2. No painel à esquerda do ambiente do notebook no navegador de arquivos, você vai notar que o repositório training-data-analyst foi adicionado.

3. Acesse o repositório clonado /training-data-analyst/quests/dataflow_python/. Nele, você vai encontrar uma pasta para cada laboratório com duas subpastas: lab, que contém o código que precisa ser concluído, e solution, que inclui um exemplo prático caso você precise de ajuda.

Observação: caso você queira editar um arquivo, é só clicar nele. O arquivo será aberto, e você poderá adicionar ou modificar o código.

Clique em Verificar meu progresso para conferir o objetivo. Crie uma instância de notebook e clone o repositório do curso

Tarefa 1: configurar o pipeline

Vamos usar o código do pipeline atual do laboratório "Como escrever pipelines com ramificações" (pasta de soluções).

Abrir o laboratório apropriado

• No terminal do ambiente do JupyterLab, execute os seguintes comandos:

cd 2_Branching_Pipelines/lab export BASE_DIR=$(pwd)

Configurar o ambiente virtual e as dependências

Antes de começar a editar o código do pipeline real, verifique se instalou as dependências necessárias.

1. Volte ao terminal aberto anteriormente no ambiente de desenvolvimento integrado e crie um ambiente virtual para o laboratório:

sudo apt-get update && sudo apt-get install -y python3-venv python3 -m venv df-env source df-env/bin/activate

2. Em seguida, instale os pacotes necessários para executar seu pipeline:

python3 -m pip install -q --upgrade pip setuptools wheel python3 -m pip install apache-beam[gcp]

3. Por fim, verifique se a API Dataflow está ativada:

gcloud services enable dataflow.googleapis.com

Configurar o ambiente de dados

• Configure o ambiente de dados:

# Create GCS buckets and BQ dataset cd $BASE_DIR/../.. source create_batch_sinks.sh # Generate event dataflow source generate_batch_events.sh # Change to the directory containing the practice version of the code cd $BASE_DIR

Atualizar o código do pipeline

• Atualize o arquivo my_pipeline.py no seu ambiente de desenvolvimento integrado usando o arquivo de solução disponível em training-data-analyst/quests/dataflow_python/2_Branching_Pipelines/solution/:

cp /home/jupyter/training-data-analyst/quests/dataflow_python/2_Branching_Pipelines/solution/my_pipeline.py $BASE_DIR

Clique em Verificar meu progresso para conferir o objetivo. Configurar o ambiente de dados

Tarefa 2: criar uma imagem de contêiner para o modelo Flex personalizado do Dataflow

1. Primeiro, ative como padrão o uso do armazenamento em cache do Kaniko. O Kaniko armazena em cache os artefatos do build de contêiner. Portanto, o uso dessa opção acelera a criação dos builds subsequentes. Também vamos usar o pip3 freeze para registrar os pacotes e as versões usadas no ambiente.

gcloud config set builds/use_kaniko True

2. Em seguida, vamos criar nosso Dockerfile. Isso especificará o código e as dependências que precisamos usar.

   a. Para concluir esta tarefa, crie um arquivo na pasta dataflow_python/2_Branching_Pipelines/lab no explorador de Arquivos do ambiente de desenvolvimento integrado.

   b. Para criar um Novo arquivo, clique em Arquivo >> Novo >> Arquivo de texto.

   c. Clique com o botão direito do mouse para renomear o arquivo como Dockerfile.

   d. Abra o arquivo Dockerfile no painel de edição e clique nele para abri-lo.

   e. Copie o código abaixo para o arquivo Dockerfile e salve:

FROM gcr.io/dataflow-templates-base/python3-template-launcher-base ARG WORKDIR=/dataflow/template RUN mkdir -p ${WORKDIR} WORKDIR ${WORKDIR} RUN apt-get update && apt-get install -y libffi-dev && rm -rf /var/lib/apt/lists/* COPY my_pipeline.py . ENV FLEX_TEMPLATE_PYTHON_PY_FILE="${WORKDIR}/my_pipeline.py" RUN python3 -m pip install apache-beam[gcp]==2.25.0

3. Por fim, use o Cloud Build para criar a imagem do contêiner:

export PROJECT_ID=$(gcloud config get-value project) export TEMPLATE_IMAGE="gcr.io/$PROJECT_ID/dataflow/my_pipeline:latest" gcloud builds submit --tag $TEMPLATE_IMAGE .

O processo de criação e envio do contêiner levará alguns minutos.

Clique em Verificar meu progresso para conferir o objetivo. Criar uma imagem de contêiner para o modelo Flex personalizado do Dataflow

Tarefa 3: criar e organizar o modelo Flex

1. Para executar um modelo, é preciso criar um arquivo de especificação no Cloud Storage com todas as informações necessárias para executar o job, como metadados e informações do SDK.

   a. Crie um Novo arquivo na pasta dataflow_python/2_Branching_Pipelines/lab do explorador de arquivos do ambiente de desenvolvimento integrado.

   b. Para criar um Novo arquivo, clique em Arquivo >> Novo >> Arquivo de texto.

   c. Clique com o botão direito do mouse para renomear o arquivo como metadata.json.

   d. Abra o arquivo metadata.json no painel de edição. Para abrir o arquivo, clique com o botão direito do mouse no metadata.json e selecione Abrir com >> Editor.

   e. Para concluir esta tarefa, precisamos criar um arquivo metadata.json no formato abaixo, que considera todos os parâmetros de entrada esperados pelo pipeline. Consulte a solução, se isso for necessário. Para isso, é necessário escrever seus próprios parâmetros de verificação de regex. Embora não seja uma prática recomendada, ".*" será uma correspondência em qualquer entrada.

{ "name": "Your pipeline name", "description": "Your pipeline description", "parameters": [ { "name": "inputPath", "label": "Input file path.", "helpText": "Path to events.json file.", "regexes": [ ".*\\.json" ] }, { "name": "outputPath", "label": "Output file location", "helpText": "GCS Coldline Bucket location for raw data", "regexes": [ "gs:\\/\\/[a-zA-z0-9\\-\\_\\/]+" ] }, { "name": "tableName", "label": "BigQuery output table", "helpText": "BigQuery table spec to write to, in the form 'project:dataset.table'.", "is_optional": true, "regexes": [ "[^:]+:[^.]+[.].+" ] } ] }

2. Em seguida, crie e organize o modelo real:

export PROJECT_ID=$(gcloud config get-value project) export TEMPLATE_PATH="gs://${PROJECT_ID}/templates/mytemplate.json" # Will build and upload the template to GCS # You may need to opt-in to beta gcloud features gcloud beta dataflow flex-template build $TEMPLATE_PATH \ --image "$TEMPLATE_IMAGE" \ --sdk-language "PYTHON" \ --metadata-file "metadata.json"

3. Verifique se o arquivo foi enviado para o local do modelo no Cloud Storage.

Clique em Verificar meu progresso para conferir o objetivo. Criar e organizar o modelo Flex

Tarefa 4: executar o modelo usando a IU

Para concluir essa tarefa, siga as instruções abaixo:

1. Acesse a página do Cloud Dataflow no Console do GCP.

2. Clique em CRIAR JOB A PARTIR DO MODELO.

3. Digite um nome válido no campo Nome do job.

4. Selecione Modelo personalizado no menu suspenso Modelo do Dataflow.

5. Digite o caminho do Cloud Storage para o arquivo de modelo no campo de caminho do Cloud Storage referente ao modelo.

6. Insira os itens relevantes em Parâmetro obrigatório.

   a. Em Caminho do arquivo de entrada, insira

   b. Em Local do arquivo de saída, insira

   c. Em Tabela de saída do BigQuery, insira

7. Clique em EXECUTAR JOB.

Observação: não é necessário especificar um bucket de preparo. O DataFlow vai criar um bucket privado no seu projeto usando o número dele, parecido com

8. Analise o console do Compute Engine. Você verá uma VM inicializadora temporária que foi criada para executar o contêiner e iniciar o pipeline com os parâmetros fornecidos.

Tarefa 5: executar o modelo usando o gcloud

Um dos benefícios de usar modelos do Dataflow é a capacidade de executá-los em vários contextos diferentes do ambiente de desenvolvimento. Para demonstrar isso, use a gcloud para executar um modelo do Dataflow na linha de comando.

1. Para concluir esta tarefa, execute este comando no seu terminal, modificando os parâmetros conforme apropriado:

export PROJECT_ID=$(gcloud config get-value project) export REGION={{{project_0.startup_script.lab_region|Region}}} export JOB_NAME=mytemplate-$(date +%Y%m%H%M$S) export TEMPLATE_LOC=gs://${PROJECT_ID}/templates/mytemplate.json export INPUT_PATH=gs://${PROJECT_ID}/events.json export OUTPUT_PATH=gs://${PROJECT_ID}-coldline/template_output/ export BQ_TABLE=${PROJECT_ID}:logs.logs_filtered gcloud beta dataflow flex-template run ${JOB_NAME} \ --region=$REGION \ --template-file-gcs-location ${TEMPLATE_LOC} \ --parameters "inputPath=${INPUT_PATH},outputPath=${OUTPUT_PATH},tableName=${BQ_TABLE}"

2. Verifique se o pipeline foi concluído corretamente.

Clique em Verificar meu progresso para conferir o objetivo. Execute o modelo pela IU e usando a gcloud

Finalize o laboratório

Clique em Terminar o laboratório após a conclusão. O Google Cloud Ensina remove os recursos usados e limpa a conta por você.

Você vai poder avaliar sua experiência no laboratório. Basta selecionar o número de estrelas, digitar um comentário e clicar em Enviar.

O número de estrelas indica o seguinte:

• 1 estrela = muito insatisfeito
• 2 estrelas = insatisfeito
• 3 estrelas = neutro
• 4 estrelas = satisfeito
• 5 estrelas = muito satisfeito

Feche a caixa de diálogo se não quiser enviar feedback.

Para enviar seu feedback, fazer sugestões ou correções, use a guia Suporte.

Copyright 2020 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.