Recuperação de desastres para o Dataproc Metastore

Este tutorial propõe uma estratégia de recuperação de desastres e continuidade do negócio de dupla região através do Dataproc Metastore. O tutorial usa contentores de duas regiões para armazenar conjuntos de dados do Hive e exportações de metadados do Hive.

O Dataproc Metastore é um serviço de metastore totalmente gerido, de elevada disponibilidade, com escala automática, autorrecuperação e nativo de OSS que simplifica significativamente a gestão de metadados técnicos. O nosso serviço gerido baseia-se no Apache Hive Metastore e serve como um componente crítico para os lagos de dados empresariais.

Este tutorial foi concebido para Google Cloud clientes que requerem elevada disponibilidade para os respetivos dados e metadados do Hive. Usa o Cloud Storage para armazenamento, Dataproc para computação e Dataproc Metastore (DPMS), um serviço Hive Metastore totalmente gerido no Google Cloud. O tutorial também apresenta duas formas diferentes de orquestrar as comutações por falha: uma usa o Cloud Run e o Cloud Scheduler, a outra usa o Cloud Composer.

A abordagem de dupla região usada no tutorial tem vantagens e desvantagens:

Vantagens

• Os contentores de duas regiões têm redundância geográfica.
• Os contentores de dupla região têm um SLA de disponibilidade de 99,95%, em comparação com a disponibilidade de 99,9% dos contentores de região única.
• Os contentores de dupla região têm um desempenho otimizado em duas regiões, enquanto os contentores de região única não têm um desempenho tão bom quando trabalham com recursos noutras regiões.

Desvantagens

• As gravações de contentores de duas regiões não são replicadas imediatamente para ambas as regiões.
• Os contentores de duas regiões têm custos de armazenamento mais elevados do que os contentores de uma única região.

Arquitetura de referência

Os diagramas de arquitetura seguintes mostram os componentes que usa neste tutorial. Em ambos os diagramas, o X vermelho grande indica a falha da região principal:

Figura 1: usar o Cloud Run e o Cloud Scheduler

Figura 2: usar o Cloud Composer

Os componentes da solução e as respetivas relações são:

• Dois contentores de dupla região do Cloud Storage: cria um contentor para os dados do Hive e um contentor para as cópias de segurança periódicas dos metadados do Hive. Crie ambos os contentores de dupla região de forma que usem as mesmas regiões que os clusters do Hadoop que acedem aos dados.
• Um metastore do Hive que usa o DPMS: cria este metastore do Hive na sua região principal (região A). A configuração da metastore aponta para o seu contentor de dados do Hive. Um cluster Hadoop que use o Dataproc tem de estar na mesma região que a instância do DPMS à qual está anexado.
• Uma segunda instância do DPMS: cria uma segunda instância do DPMS na sua região de espera (região B) para se preparar para uma falha ao nível da região. Em seguida, importa o ficheiro de exportação hive.sql mais recente do seu contentor de exportação para o DPMS de reserva. Também cria um cluster do Dataproc na região de standby e anexa-o à instância do DPMS de standby. Por último, num cenário de recuperação de desastres, redireciona as suas aplicações cliente do cluster do Dataproc na região A para o cluster do Dataproc na região B.

• Uma implementação do Cloud Run: cria uma implementação do Cloud Run na região A que exporta periodicamente os metadados do DPMS para um contentor de cópia de segurança de metadados através do Cloud Scheduler (conforme mostrado na Figura 1). A exportação assume a forma de um ficheiro SQL que contém um despejo completo dos metadados do DPMS.

  Nota: o Cloud Scheduler tem uma dependência do App Engine. Como tal, só pode ser configurado para uma região por Google Cloud projeto. Por conseguinte, use o Cloud Scheduler apenas para cenários de recuperação de desastres a curto prazo em que a duração da comutação por falha para a região B é medida em horas ou dias, em vez de semanas ou meses.

Se já tiver um ambiente do Cloud Composer, pode orquestrar as exportações e as importações de metadados do DPMS executando um DAG do Airflow nesse ambiente (conforme mostrado na Figura 2). Esta utilização de um DAG do Airflow substituiria o método do Cloud Run mencionado anteriormente.

Objetivos

• Configure o armazenamento birregional para dados do Hive e cópias de segurança do Hive Metastore.
• Implemente um Dataproc Metastore e um cluster do Dataproc nas regiões A e B.
• Faça com que a implementação falhe na região B.
• Falha na implementação de volta para a região A.
• Crie cópias de segurança automáticas do metastore do Hive.
• Orquestre exportações e importações de metadados através do Cloud Run.
• Orquestre exportações e importações de metadados através do Cloud Composer.

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

• Dataproc
• Dataproc Metastore
• Cloud Run
• Cloud Scheduler
• Cloud Composer

Para gerar uma estimativa de custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Antes de começar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.
Go to project selector
Verify that billing is enabled for your Google Cloud project.
Enable the Dataproc, and Dataproc Metastore APIs.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the APIs
Create a service account:
1. Ensure that you have the Create Service Accounts IAM role (roles/iam.serviceAccountCreator). Learn how to grant roles.

2. In the Google Cloud console, go to the Create service account page.

   Go to Create service account
3. Select your project.

4. In the Service account name field, enter a name. The Google Cloud console fills in the Service account ID field based on this name.

   In the Service account description field, enter a description. For example, Service account for quickstart.

5. Click Create and continue.

6. Grant the Project > Owner role to the service account.

   To grant the role, find the Select a role list, then select Project > Owner.

   Note: The Role field affects which resources the service account can access in your project. You can revoke these roles or grant additional roles later. In production environments, do not grant the Owner, Editor, or Viewer roles. Instead, grant a predefined role or custom role that meets your needs.
7. Click Continue.

8. Click Done to finish creating the service account.

   Do not close your browser window. You will use it in the next step.
Create a service account key:
1. In the Google Cloud console, click the email address for the service account that you created.
2. Click Keys.
3. Click Add key, and then click Create new key.
4. Click Create. A JSON key file is downloaded to your computer.
5. Click Close.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Dataproc, and Dataproc Metastore APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Create a service account:

1. Ensure that you have the Create Service Accounts IAM role (roles/iam.serviceAccountCreator). Learn how to grant roles.

2. In the Google Cloud console, go to the Create service account page.

   Go to Create service account
3. Select your project.

4. In the Service account name field, enter a name. The Google Cloud console fills in the Service account ID field based on this name.

   In the Service account description field, enter a description. For example, Service account for quickstart.

5. Click Create and continue.

6. Grant the Project > Owner role to the service account.

   To grant the role, find the Select a role list, then select Project > Owner.

   Note: The Role field affects which resources the service account can access in your project. You can revoke these roles or grant additional roles later. In production environments, do not grant the Owner, Editor, or Viewer roles. Instead, grant a predefined role or custom role that meets your needs.
7. Click Continue.

8. Click Done to finish creating the service account.

   Do not close your browser window. You will use it in the next step.

Create a service account key:

1. In the Google Cloud console, click the email address for the service account that you created.
2. Click Keys.
3. Click Add key, and then click Create new key.
4. Click Create. A JSON key file is downloaded to your computer.
5. Click Close.

Inicialize o ambiente

1. No Cloud Shell, inicie uma instância do Cloud Shell.

2. Clone o repositório do GitHub do tutorial:

   git clone https://github.com/GoogleCloudPlatform/metastore-disaster-recovery.git
   

3. Ative as seguintes Google Cloud APIs:

   gcloud services enable dataproc.googleapis.com metastore.googleapis.com
   

4. Defina algumas variáveis de ambiente:

   export PROJECT=$(gcloud info --format='value(config.project)')
   export WAREHOUSE_BUCKET=${PROJECT}-warehouse
   export BACKUP_BUCKET=${PROJECT}-dpms-backups
   export DPMS_PRIMARY_REGION=us-central1
   export DPMS_STANDBY_REGION=us-east1
   export DPMS_PRIMARY_INSTANCE=dpms1
   export DPMS_STANDBY_INSTANCE=dpms2
   export HADOOP_PRIMARY=dataproc-cluster1
   export HADOOP_STANDBY=dataproc-cluster2
   

Criar armazenamento para dados do Hive e cópias de segurança do Hive Metastore

Nesta secção, cria contentores do Cloud Storage para alojar os dados do Hive e as cópias de segurança do Hive Metastore.

Crie armazenamento de dados do Hive

1. No Cloud Shell, crie um contentor em duas regiões para alojar os dados do Hive:

   gcloud storage buckets create gs://${WAREHOUSE_BUCKET} --location=NAM4
   

2. Copie alguns dados de exemplo para o contentor de dados do Hive:

   gcloud storage cp gs://retail_csv gs://${WAREHOUSE_BUCKET}/retail --recursive
   

Crie armazenamento para cópias de segurança de metadados

• No Cloud Shell, crie um contentor de duas regiões para alojar as cópias de segurança dos metadados do DPMS:

  gcloud storage buckets create gs://${BACKUP_BUCKET} --location=NAM4
  

Implementar recursos de computação na região principal

Nesta secção, implementa todos os recursos de computação na região principal, incluindo a instância do DPMS e o cluster do Dataproc. Também preenche o Dataproc Metastore com metadados de exemplo.

Crie a instância do DPMS

1. No Cloud Shell, crie a instância do DPMS:

   gcloud metastore services create ${DPMS_PRIMARY_INSTANCE} \
       --location=${DPMS_PRIMARY_REGION} \
       --hive-metastore-version=3.1.2
   

   Este comando pode demorar alguns minutos a ser concluído.

   Nota: a versão 3.1.2 do Hive Metastore é compatível com a versão 2.0 da imagem do Dataproc. Ambos usam a versão 3.1.2 do Hive. Se usar uma versão diferente do Hive Metastore, certifique-se de que usa uma imagem do Dataproc compatível com a versão do Hive.

2. Defina o contentor de dados do Hive como o diretório do armazém predefinido:

   gcloud metastore services update ${DPMS_PRIMARY_INSTANCE} \
       --location=${DPMS_PRIMARY_REGION} \
       --update-hive-metastore-configs="hive.metastore.warehouse.dir=gs://${PROJECT}-  warehouse"
   

   Este comando pode demorar alguns minutos a ser concluído.

Crie um cluster do Dataproc

• No Cloud Shell, crie um cluster do Dataproc e anexe-o à instância do DPMS:

  gcloud dataproc clusters create ${HADOOP_PRIMARY} \
      --dataproc-metastore=projects/${PROJECT}/locations/${DPMS_PRIMARY_REGION}/services/${DPMS_PRIMARY_INSTANCE} \
      --region=${DPMS_PRIMARY_REGION} \
      --image-version=2.0
  

  Especifique a imagem do cluster como versão 2.0, que é a versão mais recente disponível a partir de junho de 2021. Também é a primeira versão que suporta DPMS.

Preencha o metastore

1. No Cloud Shell, atualize o exemplo retail.hql fornecido no repositório deste tutorial com o nome do contentor de dados do Hive:

   sed -i -- 's/${WAREHOUSE_BUCKET}/'"$WAREHOUSE_BUCKET"'/g' retail.hql
   

2. Execute as consultas contidas no ficheiro retail.hql para criar as definições de tabelas no metastore:

   gcloud dataproc jobs submit hive \
       --cluster=${HADOOP_PRIMARY} \
       --region=${DPMS_PRIMARY_REGION} \
       --file=retail.hql
   

3. Verifique se as definições das tabelas foram criadas corretamente:

   gcloud dataproc jobs submit hive \
       --cluster=${HADOOP_PRIMARY} \
       --region=${DPMS_PRIMARY_REGION} \
       --execute="
       desc departments;
       desc categories;
       desc products;
       desc order_items;
       desc orders;
       desc customers;
   
       select count(*) as num_departments from departments;
       select count(*) as num_categories from categories;
       select count(*) as num_products from products;
       select count(*) as num_order_items from order_items;
       select count(*) as num_orders from orders;
       select count(*) as num_customers from customers;
     "
   

   O resultado é semelhante ao seguinte:

   +------------------+------------+----------+
   |     col_name     | data_type  | comment  |
   +------------------+------------+----------+
   | department_id    | int        |          |
   | department_name  | string     |          |
   +------------------+------------+----------+
   

   A saída também contém o número de elementos em cada tabela. Por exemplo:

   +----------------+
   | num_customers  |
   +----------------+
   | 12435          |
   +----------------+
   

Transição para a região de reserva

Esta secção fornece os passos para a comutação por falha da região principal (região A) para a região de reserva (região B).

1. No Cloud Shell, exporte os metadados da instância do DPMS principal para o contentor de cópias de segurança:

   gcloud metastore services export gcs ${DPMS_PRIMARY_INSTANCE}  \
       --location=${DPMS_PRIMARY_REGION} \
       --destination-folder=gs://${BACKUP_BUCKET}
   

   O resultado é semelhante ao seguinte:

   metadataManagementActivity:
   metadataExports:
   ‐ databaseDumpType: MYSQL
       destinationGcsUri: gs://qa01-300915-dpms-backups/hive-export-2021-05-04T22:21:53.288Z
       endTime: '2021-05-04T22:23:35.982214Z'
       startTime: '2021-05-04T22:21:53.308534Z'
       state: SUCCEEDED
   

   Tenha em atenção o valor no atributo destinationGcsUri. Este atributo armazena a cópia de segurança que criou.

2. Crie uma nova instância do DPMS na região de standby:

   gcloud metastore services create ${DPMS_STANDBY_INSTANCE} \
       --location=${DPMS_STANDBY_REGION} \
       --hive-metastore-version=3.1.2
   

3. Defina o contentor de dados do Hive como o diretório do armazém predefinido:

   gcloud metastore services update ${DPMS_STANDBY_INSTANCE} \
       --location=${DPMS_STANDBY_REGION} \
       --update-hive-metastore-configs="hive.metastore.warehouse.dir=gs://${PROJECT}-warehouse"
   

4. Recupere o caminho da cópia de segurança de metadados mais recente:

   IMPORT_DIR=`gcloud storage ls gs://${BACKUP_BUCKET} | sort -k 1 | tail -1`
   IMPORT_SQL="${IMPORT_DIR}hive.sql"
   echo ${IMPORT_SQL}
   

5. Importe os metadados da cópia de segurança para a nova instância do Dataproc Metastore:

   gcloud metastore services import gcs ${DPMS_STANDBY_INSTANCE} \
       --location=${DPMS_STANDBY_REGION} \
       --dump-type=mysql \
       --database-dump=${IMPORT_SQL} \
       --import-id=import-$(date +"%Y-%m-%d-%H-%M-%S")
   

6. Crie um cluster do Dataproc na região de espera (região B):

   gcloud dataproc clusters create ${HADOOP_STANDBY} \
       --dataproc-metastore=projects/${PROJECT}/locations/${DPMS_STANDBY_REGION}/services/${DPMS_STANDBY_INSTANCE} \
       --region=${DPMS_STANDBY_REGION} \
       --image-version=2.0
   

7. Verifique se os metadados foram importados corretamente:

   gcloud dataproc jobs submit hive \
       --cluster ${HADOOP_STANDBY} \
       --region ${DPMS_STANDBY_REGION} \
       --execute "select count(*) as num_orders from orders;"
   

   O num_ordersresultado é o mais importante para o tutorial. É semelhante ao seguinte:

   +-------------+
   | num_orders  |
   +-------------+
   | 68883       |
   +-------------+
   

   O Dataproc Metastore principal tornou-se o novo Dataproc Metastore de reserva e o Dataproc Metastore de reserva tornou-se o novo Dataproc Metastore principal.

8. Atualize as variáveis de ambiente com base nestas novas funções:

   export DPMS_PRIMARY_REGION=us-east1
   export DPMS_STANDBY_REGION=us-central1]
   export DPMS_PRIMARY_INSTANCE=dpms2
   export DPMS_STANDBY_INSTANCE=dpms1
   export HADOOP_PRIMARY=dataproc-cluster2
   export HADOOP_STANDBY=dataproc-cluster1
   

9. Verifique se consegue escrever no novo Metastore do Dataproc principal na região B:

   gcloud dataproc jobs submit hive \
       --cluster ${DPMS_PRIMARY_INSTANCE} \
       --region ${DPMS_PRIMARY_REGION} \
       --execute "create view completed_orders as select * from orders where order_status = 'COMPLETE';"
   
   gcloud dataproc jobs submit hive \
       --cluster ${HADOOP_PRIMARY} \
       --region ${DPMS_PRIMARY_REGION} \
       --execute "select * from completed_orders limit 5;"
   

   A saída contém o seguinte:

   +----------------------------+------------------------------+-------------------------------------+--------------------------------+
   | completed_orders.order_id  | completed_orders.order_date  | completed_orders.order_customer_id  | completed_orders.order_status  |
   +----------------------------+------------------------------+-------------------------------------+--------------------------------+
   | 3                          | 2013-07-25 00:00:00.0        | 12111                               | COMPLETE                       |
   | 5                          | 2013-07-25 00:00:00.0        | 11318                               | COMPLETE                       |
   | 6                          | 2013-07-25 00:00:00.0        | 7130                                | COMPLETE                       |
   | 7                          | 2013-07-25 00:00:00.0        | 4530                                | COMPLETE                       |
   | 15                         | 2013-07-25 00:00:00.0        | 2568                                | COMPLETE                       |
   +----------------------------+------------------------------+-------------------------------------+--------------------------------+
   

A comutação por falha está agora concluída. Agora, deve redirecionar as suas aplicações cliente para o novo cluster principal do Dataproc na região B atualizando os ficheiros de configuração do cliente Hadoop.

Regressar à região original

Esta secção fornece os passos para reverter para a região original (região A).

1. No Cloud Shell, exporte os metadados da instância do DPMS:

   gcloud metastore services export gcs ${DPMS_PRIMARY_INSTANCE} \
       --location=${DPMS_PRIMARY_REGION} \
       --destination-folder=gs://${BACKUP_BUCKET}
   

2. Recupere o caminho da cópia de segurança de metadados mais recente:

   IMPORT_DIR=`gcloud storage ls gs://${BACKUP_BUCKET} | sort -k 1 | tail -1`
   IMPORT_SQL="${IMPORT_DIR}hive.sql"
   echo ${IMPORT_SQL}
   

3. Importe os metadados para a instância do DPMS em espera na região original (região A):

   gcloud metastore services import gcs ${DPMS_STANDBY_INSTANCE} \
       --location=${DPMS_STANDBY_REGION} \
       --dump-type=mysql \
       --database-dump=${IMPORT_SQL} \
       --import-id=import-$(date +"%Y-%m-%d-%H-%M-%S")
   

4. Verifique se os metadados foram importados corretamente:

   gcloud dataproc jobs submit hive \
       --cluster ${HADOOP_STANDBY} \
       --region ${DPMS_STANDBY_REGION} \
       --execute "select * from completed_orders limit 5;"
   

   A saída inclui o seguinte:

   +----------------------------+------------------------------+-------------------------------------+--------------------------------+
   | completed_orders.order_id  | completed_orders.order_date  | completed_orders.order_customer_id  | completed_orders.order_status  |
   +----------------------------+------------------------------+-------------------------------------+--------------------------------+
   | 3                          | 2013-07-25 00:00:00.0        | 12111                               | COMPLETE                       |
   | 5                          | 2013-07-25 00:00:00.0        | 11318                               | COMPLETE                       |
   | 6                          | 2013-07-25 00:00:00.0        | 7130                                | COMPLETE                       |
   | 7                          | 2013-07-25 00:00:00.0        | 4530                                | COMPLETE                       |
   | 15                         | 2013-07-25 00:00:00.0        | 2568                                | COMPLETE                       |
   +----------------------------+------------------------------+-------------------------------------+--------------------------------+
   

O Dataproc Metastore principal e o Dataproc Metastore em espera trocaram novamente de funções.

1. Atualize as variáveis de ambiente para estas novas funções:

   export DPMS_PRIMARY_REGION=us-central1
   export DPMS_STANDBY_REGION=us-east1
   export DPMS_PRIMARY_INSTANCE=dpms1
   export DPMS_STANDBY_INSTANCE=dpms12
   export HADOOP_PRIMARY=dataproc-cluster1
   export HADOOP_STANDBY=dataproc-cluster2
   

A reversão está agora concluída. Agora, deve redirecionar as suas aplicações cliente para o novo cluster primário do Dataproc na região A atualizando os ficheiros de configuração do cliente Hadoop.

Criar cópias de segurança de metadados automatizadas

Esta secção descreve dois métodos diferentes de automatizar as exportações e as importações de cópias de segurança de metadados. O primeiro método, Opção 1: Cloud Run e Cloud Scheduler, usa o Cloud Run e o Cloud Scheduler. O segundo método, Opção 2: Cloud Composer, usa o Cloud Composer. Em ambos os exemplos, uma tarefa de exportação cria uma cópia de segurança dos metadados do DPMS principal na região A. Uma tarefa de importação preenche o DPMS em espera na região B a partir da cópia de segurança.

Se já tiver um cluster do Cloud Composer, deve considerar a Opção 2: Cloud Composer (partindo do princípio de que o cluster tem capacidade de computação suficiente). Caso contrário, opte pela Opção 1: Cloud Run e Cloud Scheduler. Esta opção usa um modelo de preços de pagamento conforme o uso e é mais económica do que o Cloud Composer, que requer a utilização de recursos de computação persistentes.

Opção 1: Cloud Run e Cloud Scheduler

Esta secção mostra como usar o Cloud Run e o Cloud Scheduler para automatizar as exportações de importações de metadados do DPMS.

Serviços do Cloud Run

Esta secção mostra como criar dois serviços do Cloud Run para executar as tarefas de exportação e importação de metadados.

1. No Cloud Shell, ative as APIs Cloud Run, Cloud Scheduler, Cloud Build e App Engine:

   gcloud services enable run.googleapis.com cloudscheduler.googleapis.com cloudbuild.googleapis.com appengine.googleapis.com
   

   Ativa a API App Engine porque o serviço Cloud Scheduler requer o App Engine.

2. Crie a imagem do Docker com o Dockerfile fornecido:

   cd metastore-disaster-recovery
   gcloud builds submit --tag gcr.io/$PROJECT/dpms_dr
   

3. Implemente a sua imagem de contentor num serviço do Cloud Run na região principal (região A). Esta implementação é responsável pela criação de cópias de segurança dos metadados a partir do metastore principal:

   gcloud run deploy dpms-export \
       --image gcr.io/${PROJECT}/dpms_dr \
       --region ${DPMS_PRIMARY_REGION} \
       --platform managed \
       --update-env-vars DPMS_STANDBY_REGION=${DPMS_STANDBY_REGION},BACKUP_BUCKET=${BACKUP_BUCKET},DPMS_STANDBY_INSTANCE=${DPMS_STANDBY_INSTANCE},DPMS_PRIMARY_INSTANCE=${DPMS_PRIMARY_INSTANCE},DPMS_PRIMARY_REGION=${DPMS_PRIMARY_REGION} \
       --allow-unauthenticated \
       --timeout=10m
   

   Por predefinição, um pedido de serviço do Cloud Run excede o tempo limite após 5 minutos. Para ajudar a garantir que todos os pedidos têm tempo suficiente para serem concluídos com êxito, o exemplo de código anterior prolonga o valor de tempo limite para, pelo menos, 10 minutos.

4. Obtenha o URL de implementação do serviço do Cloud Run:

   EXPORT_RUN_URL=$(gcloud run services describe dpms-export --platform
   managed --region ${DPMS_PRIMARY_REGION} --format `
   "value(status.address.url)")
   echo ${EXPORT_RUN_URL}
   

5. Crie um segundo serviço do Cloud Run na região de standby (região B). Este serviço é responsável pela importação das cópias de segurança dos metadados de BACKUP_BUCKET para o metastore em espera:

   gcloud run deploy dpms-import \
       --image gcr.io/${PROJECT}/dpms_dr \
       --region ${DPMS_STANDBY_REGION} \
       --platform managed \
       --update-env-vars DPMS_STANDBY_REGION=${DPMS_STANDBY_REGION},BACKUP_BUCKET=${BACKUP_BUCKET},DPMS_STANDBY_INSTANCE=${DPMS_STANDBY_INSTANCE} \
       --allow-unauthenticated \
       --timeout=10m
   

6. Obtenha o URL de implementação do segundo serviço do Cloud Run:

     IMPORT_RUN_URL=$(gcloud run services describe dpms-import --platform
     managed --region ${REGION_B} --format "value(status.address.url)")
     echo ${IMPORT_RUN_URL}
   

Agendamento de tarefas

Esta secção mostra como usar o Cloud Scheduler para acionar os dois serviços do Cloud Run.

1. No Cloud Shell, crie uma aplicação do App Engine, que o Cloud Scheduler requer:

   gcloud app create --region=${REGION_A}
   

2. Crie uma tarefa do Cloud Scheduler para agendar as exportações de metadados do metastore principal:

   gcloud scheduler jobs create http dpms-export \
       --schedule "*/15 * * * *" \
       --http-method=post \
       --uri=${EXPORT_RUN_URL}/export\
   

O trabalho do Cloud Scheduler faz um pedido http ao serviço do Cloud Run a cada 15 minutos. O serviço do Cloud Run executa uma aplicação Flask em contentores com uma função de exportação e uma função de importação. Quando a função de exportação é acionada, exporta os metadados para o Cloud Storage através do comando gcloud metastore services export.

Em geral, se as suas tarefas do Hadoop escreverem frequentemente no Hive Metastore, recomendamos que faça cópias de segurança do metastore com frequência. Uma boa programação de cópias de segurança deve estar no intervalo de 15 a 60 minutos.

1. Acione uma execução de teste do serviço do Cloud Run:

   gcloud scheduler jobs run dpms-export
   

2. Verifique se o Cloud Scheduler acionou corretamente a operação de exportação do DPMS:

   gcloud metastore operations list --location ${REGION_A}
   

   O resultado é semelhante ao seguinte:

   OPERATION_NAME                                           LOCATION     TYPE             TARGET                             DONE  CREATE_TIME          DURATION
    ...
   operation-a520936204508-5v23bx4y23f60-920f0a0f-9c2b56b5  us-central1  update  dpms1                       True  2021-05-13T20:05:04  2M23S
   

   Se o valor de DONE for False, a exportação ainda está em curso. Para confirmar que a operação está concluída, volte a executar o comando gcloud metastore operations list --location ${REGION_A} até que o valor se torne True.

   Saiba mais sobre os gcloud metastore operationscomandos na documentação de referência.

3. (Opcional) Crie uma tarefa do Cloud Scheduler para agendar as importações para o metastore em espera:

   gcloud scheduler jobs create http dpms-import \
       --schedule "*/15 * * * *" \
       --http-method=post \
       --uri=${IMPORT_RUN_URL}/import
   

Este passo depende dos seus requisitos de tempo de recuperação (RTO).

Se quiser uma espera ativa para minimizar o tempo de comutação por falha, deve agendar esta tarefa de importação. Atualiza o DPMS em modo de espera a cada 15 minutos.

Se um modo de espera a frio for suficiente para as suas necessidades de RTO, pode ignorar este passo e também eliminar o DPMS e o cluster do Dataproc em modo de espera para reduzir ainda mais a sua fatura mensal geral. Quando fizer a comutação por falha para a região de reserva (região B), aprovisione o DPMS de reserva e o cluster do Dataproc, e execute também uma tarefa de importação. Uma vez que os ficheiros de cópia de segurança são armazenados num contentor de duas regiões, estão acessíveis mesmo que a sua região principal (região A) fique indisponível.

Lidar com as comutações por falha

Depois de fazer a comutação por falha para a região B, tem de aplicar os seguintes passos para preservar os requisitos de recuperação de desastres e proteger a sua infraestrutura contra uma potencial falha na região B:

• Pause as tarefas do Cloud Scheduler existentes.
• Atualize a região do DPMS da propriedade principal para a região B (us-east1).
• Atualize a região DPMS do modo de espera para a região A (us-central1).
• Atualize a instância principal do DPMS para dpms2.
• Atualize a instância de espera do DPMS para dpms1.
• Volte a implementar os serviços do Cloud Run com base nas variáveis atualizadas.
• Crie novas tarefas do Cloud Scheduler que apontem para os seus novos serviços do Cloud Run.

Os passos necessários na lista anterior repetem muitos dos passos das secções anteriores, apenas com pequenas alterações (como a troca dos nomes das regiões). Use as informações na Opção 1: Cloud Run e Cloud Scheduler para concluir este trabalho necessário.

Opção 2: Cloud Composer

Esta secção mostra como usar o Cloud Composer para executar as tarefas de exportação e importação num único Airflow gráfico acíclico dirigido (DAG).

1. No Cloud Shell, ative a API Cloud Composer:

   gcloud services enable composer.googleapis.com
   

2. Crie um ambiente do Cloud Composer:

   export COMPOSER_ENV=comp-env
   gcloud beta composer environments create ${COMPOSER_ENV} \
       --location ${DPMS_PRIMARY_REGION} \
       --image-version composer-1.17.0-preview.1-airflow-2.0.1 \
       --python-version 3
   

   • A imagem do compositor composer-1.17.0-preview.1-airflow-2.0.1 é a versão mais recente à data da publicação.
   • Os ambientes do Composer só podem usar uma versão principal do Python. O Python 3 foi selecionado porque o Python 2 tem problemas de capacidade de suporte.

3. Configure o seu ambiente do Cloud Composer com estas variáveis de ambiente:

   gcloud composer environments update ${COMPOSER_ENV} \
       --location ${DPMS_PRIMARY_REGION} \
       --update-env-variables=DPMS_PRIMARY_REGION=${DPMS_PRIMARY_REGION},DPMS_STANDBY_REGION=${DPMS_STANDBY_REGION},BACKUP_BUCKET=${BACKUP_BUCKET},DPMS_PRIMARY_INSTANCE=${DPMS_PRIMARY_INSTANCE},DPMS_STANDBY_INSTANCE=${DPMS_STANDBY_INSTANCE}
   

4. Carregue o ficheiro DAG para o seu ambiente do Composer:

   gcloud composer environments storage dags import \
       --environment ${COMPOSER_ENV} \
       --location ${DPMS_PRIMARY_REGION} \
       --source dpms_dag.py
   

5. Recupere o URL do Airflow:

   gcloud composer environments describe ${COMPOSER_ENV} \
       --location ${DPMS_PRIMARY_REGION} \
       --format "value(config.airflowUri)"
   

6. No navegador, abra o URL devolvido pelo comando anterior.

   Deve ver uma nova entrada de DAG denominada dpms_dag. Numa única execução, o DAG executa uma exportação, seguida de uma importação. O DAG pressupõe que o DPMS em espera está sempre ativo. Se não precisar de um modo de espera a quente e quiser apenas executar a tarefa de exportação, deve comentar todas as tarefas relacionadas com a importação no código (find_backup, wait_for_ready_status, current_ts, dpms_import).

7. Clique no ícone de seta para acionar o DAG para fazer um teste de execução:

   

8. Clique em Vista de gráfico do DAG em execução para verificar o estado de cada tarefa:

   

   Depois de validar o DAG, deixe o Airflow executá-lo regularmente. O horário está definido para um intervalo de 30 minutos, mas pode ser ajustado alterando o parâmetro schedule_interval no código para cumprir os seus requisitos de tempo.

Lide com as comutações por falha

Depois de fazer a comutação por falha para a região B, tem de aplicar os seguintes passos para preservar os requisitos de recuperação de desastres e proteger a sua infraestrutura contra uma potencial falha na região B:

• Atualize a região do DPMS da propriedade principal para a região B (us-east1).
• Atualize a região DPMS do modo de espera para a região A (us-central1).
• Atualize a instância principal do DPMS para dpms2.
• Atualize a instância de espera do DPMS para dpms1.
• Crie um novo ambiente do Cloud Composer na região B (us-east1).
• Configure o ambiente do Cloud Composer com as variáveis de ambiente atualizadas.
• Importe o mesmo DAG do Airflow que antes para o seu novo ambiente do Cloud Composer.dpms_dag

Os passos necessários na lista anterior repetem muitos dos passos das secções anteriores, apenas com pequenas alterações (como a troca dos nomes das regiões). Use as informações na Opção 2: Cloud Composer para concluir este trabalho necessário.

Limpar

Para evitar incorrer em custos na sua conta do Google Cloud pelos recursos usados neste tutorial, elimine o projeto que contém os recursos ou mantenha o projeto e elimine os recursos individuais.

Atenção: a eliminação de um projeto tem os seguintes efeitos:

• Tudo no projeto é eliminado. Se usou um projeto existente para as tarefas neste documento, quando o elimina, também elimina qualquer outro trabalho que tenha feito no projeto.
• Os IDs dos projetos personalizados são perdidos. Quando criou este projeto, pode ter criado um ID do projeto personalizado que quer usar no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, elimine os recursos selecionados no projeto em vez de eliminar o projeto inteiro.

Se planeia explorar várias arquiteturas, tutoriais ou inícios rápidos, a reutilização de projetos pode ajudar a evitar exceder os limites de quota de projetos.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

O que se segue?

• Saiba como monitorizar a sua instância do Dataproc Metastore
• Compreenda como sincronizar o seu metastore do Hive com o catálogo de dados
• Saiba mais sobre como desenvolver serviços do Cloud Run
• Para ver mais arquiteturas de referência, diagramas e práticas recomendadas, explore o Centro de arquitetura na nuvem.