Cette page a été traduite par l'API Cloud Translation.

Reprise après sinistre pour Dataproc Metastore

Dataproc Metastore

Ce tutoriel propose une stratégie de reprise après sinistre birégionale et de continuité des opérations à l'aide de Dataproc Metastore. Dans ce tutoriel, nous utilisons des buckets birégionaux pour stocker les exportations d'ensembles de données Hive et de métadonnées Hive.

Dataproc Metastore est une solution Open Source entièrement gérée, hautement disponible, avec autoscaling, autoréparation et Open Source qui simplifie considérablement la gestion des métadonnées techniques. Notre service géré est basé sur Apache Hive Metastore et joue un rôle essentiel dans les lacs de données d'entreprise.

Ce tutoriel est conçu pour les clients Google Cloud qui ont besoin d'une haute disponibilité pour leurs données et métadonnées Hive. Il utilise Cloud Storage pour le stockage, Dataproc pour le calcul et Dataproc Metastore (DPMS), un service Hive Metastore entièrement géré sur Google Cloud. Ce tutoriel présente également deux méthodes différentes d'orchestration des basculements : l'une utilise Cloud Run et Cloud Scheduler, l'autre utilise Cloud Composer.

L'approche birégionale utilisée dans ce tutoriel présente des avantages et des inconvénients :

Avantages

Les buckets birégionaux sont géoredondants.
Les buckets birégionaux présentent une disponibilité de 99,95 % dans le contrat de niveau de service, contre 99,9 % pour les buckets à région unique.
Les buckets birégionaux offrent des performances optimisées dans deux régions, tandis que les buckets à région unique ne fonctionnent pas aussi bien avec des ressources situées dans d'autres régions.

Inconvénients

Les écritures de bucket birégional ne sont pas immédiatement dupliquées dans les deux régions.
Les coûts de stockage des buckets birégionaux sont plus élevés que ceux des buckets à région unique.

Architecture de référence

Les schémas d'architecture suivants illustrent les composants que vous utilisez dans ce tutoriel. Dans les deux schémas, le grand X rouge indique la défaillance de la région principale:

Figure 1: Utiliser Cloud Run et Cloud Scheduler

Utilisez Cloud Composer pour basculer d'une région principale à une région secondaire. Figure 2: Utiliser Cloud Composer

Les composants de la solution et leurs relations sont les suivants:

Deux buckets birégionaux Cloud Storage : vous créez un bucket pour les données Hive et un bucket pour les sauvegardes périodiques des métadonnées Hive. Créez les deux buckets birégionaux de sorte qu'ils utilisent les mêmes régions que les clusters Hadoop qui accèdent aux données.
Metastore Hive à l'aide de DPMS:vous créez ce métastore Hive dans votre région principale (région A). La configuration du métastore pointe vers votre bucket de données Hive. Un cluster Hadoop utilisant Dataproc doit se trouver dans la même région que l'instance DPMS à laquelle il est associé.
Une deuxième instance DPMS:créez une deuxième instance DPMS dans la région de secours (région B) pour préparer une défaillance à l'échelle de la région. Vous importez ensuite le fichier d'exportation hive.sql le plus récent de votre bucket d'exportation vers votre DPMS de secours. Vous allez également créer un cluster Dataproc dans votre région de secours et l'associer à votre instance DPMS de secours. Enfin, dans un scénario de reprise après sinistre, vous redirigez vos applications clientes de votre cluster Dataproc de la région A vers votre cluster Dataproc dans la région B.
Déploiement Cloud Run:vous créez un déploiement Cloud Run dans la région A qui exporte périodiquement les métadonnées DPMS dans un bucket de sauvegarde de métadonnées à l'aide de Cloud Scheduler (comme illustré à la figure 1). ). L'exportation prend la forme d'un fichier SQL contenant un vidage complet des métadonnées DPMS.

Remarque :Cloud Scheduler dépend d'App Engine. Par conséquent, il ne peut être configuré que pour une seule région par projet Google Cloud. Par conséquent, utilisez Cloud Scheduler uniquement pour les scénarios de reprise après sinistre à court terme dans lesquels la durée du basculement vers la région B est mesurée en heures ou en jours, plutôt qu'en semaines ou en mois.

Si vous possédez déjà un environnement Cloud Composer, vous pouvez orchestrer les exportations et les importations de métadonnées DPMS en exécutant un DAG Airflow sur cet environnement (comme illustré à la figure 2). Cette utilisation d'un DAG Airflow serait mise en place à la place de la méthode Cloud Run mentionnée précédemment.

Objectifs

Configurez le stockage birégional pour les données Hive et les sauvegardes Hive Metastore.
Déployer un métastore et un cluster Dataproc dans les régions A et B
Faites basculer le déploiement vers la région B.
Restaurer le déploiement vers la région A.
Créez des sauvegardes automatiques de métastore Hive.
Coordonnez les exportations et les importations de métadonnées via Cloud Run.
Coordonner les exportations et les importations de métadonnées via Cloud Composer.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

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.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Dataproc, and Dataproc Metastore APIs.

Enable the APIs

Create a service account:

In the Google Cloud console, go to the Create service account page.
Go to Create service account
Select your project.
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.
Click Create and continue.
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.
Click Continue.
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:

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

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Dataproc, and Dataproc Metastore APIs.

Enable the APIs

Create a service account:

In the Google Cloud console, go to the Create service account page.
Go to Create service account
Select your project.
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.
Click Create and continue.
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.
Click Continue.
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:

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

Initialiser l'environnement

Dans Cloud Shell, démarrez une instance Cloud Shell.

Clonez le dépôt GitHub du tutoriel :

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

Activez les API Google Cloud suivantes:

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

Définissez des variables d'environnement.

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

Créer un espace de stockage pour les données Hive et les sauvegardes Hive Metastore

Dans cette section, vous allez créer des buckets Cloud Storage pour héberger les sauvegardes Hive Metastore et les données Hive.

Créer un stockage de données Hive

Dans Cloud Shell, créez un bucket birégional pour héberger les données Hive :
```
gcloud storage buckets create gs://${WAREHOUSE_BUCKET} --location=NAM4
```

Copiez des exemples de données dans le bucket de données Hive:

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

Créer un espace de stockage pour les sauvegardes de métadonnées

Dans Cloud Shell, créez un bucket birégional pour héberger les sauvegardes de métadonnées DPMS :
```
gcloud storage buckets create gs://${BACKUP_BUCKET} --location=NAM4
```

Déployer des ressources de calcul dans la région principale

Dans cette section, vous déployez toutes les ressources de calcul dans la région principale, y compris l'instance DPMS et le cluster Dataproc. Vous remplissez également le métastore Dataproc avec des exemples de métadonnées.

Créer l'instance DPMS

Dans Cloud Shell, créez l'instance DPMS :
```
gcloud metastore services create ${DPMS_PRIMARY_INSTANCE} \
    --location=${DPMS_PRIMARY_REGION} \
    --hive-metastore-version=3.1.2
```
L'exécution de cette commande peut prendre plusieurs minutes.

Remarque :La version 3.1.2 de Hive Metastore est compatible avec la version de l'image Dataproc 2.0. Ils utilisent tous deux la version 3.1.2 de Hive. Si vous utilisez une autre version de Hive Metastore, veillez à utiliser une image Dataproc compatible correspondant à la version de Hive.

Définissez le bucket de données Hive comme répertoire d'entrepôt par défaut:

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

L'exécution de cette commande peut prendre plusieurs minutes.

Créer un cluster Dataproc

Dans Cloud Shell, créez un cluster Dataproc et associez-le à l'instance 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
```
Spécifiez l'image de cluster en tant que version 2.0, qui est la dernière version disponible depuis juin 2021. Il s'agit également de la première version compatible avec DPMS.

Insérer des valeurs dans le métastore

Dans Cloud Shell, mettez à jour l'exemple de fichier retail.hql fourni dans le dépôt de ce tutoriel avec le nom du bucket de données Hive :
```
sed -i -- 's/${WAREHOUSE_BUCKET}/'"$WAREHOUSE_BUCKET"'/g' retail.hql
```

Exécutez les requêtes contenues dans le fichier retail.hql pour créer les définitions de table dans le métastore:

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

Vérifiez que les définitions de table ont été correctement créées:

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

Le résultat se présente comme suit :

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

La sortie contient également le nombre d'éléments dans chaque table, par exemple:

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

Basculer vers la région de secours

Cette section fournit les étapes permettant de basculer de la région principale (région A) vers la région de secours (région B).

Dans Cloud Shell, exportez les métadonnées de l'instance DPMS principale vers le bucket de sauvegarde:

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

Le résultat se présente comme suit :

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

Notez la valeur de l'attribut destinationGcsUri. Cet attribut stocke la sauvegarde que vous avez créée.

Créez une instance DPMS dans la région de secours:

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

Définissez le bucket de données Hive comme répertoire d'entrepôt par défaut:

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

Récupérez le chemin de la dernière sauvegarde de métadonnées:

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

Importez les métadonnées sauvegardées dans la nouvelle instance 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")

Créez un cluster Dataproc dans la région de secours (région 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

Vérifiez que les métadonnées ont été correctement importées:
```
gcloud dataproc jobs submit hive \
    --cluster ${HADOOP_STANDBY} \
    --region ${DPMS_STANDBY_REGION} \
    --execute "select count(*) as num_orders from orders;"
```
La sortie num_orders est la plus importante pour le tutoriel. Elle se présente comme suit:
```
+-------------+
| num_orders  |
+-------------+
| 68883       |
+-------------+
```
Le métastore Dataproc principal est devenu le nouveau métastore de secours, et le métastore de secours est devenu le nouveau métastore principal.

Mettez à jour les variables d'environnement en fonction des nouveaux rôles suivants:

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

Vérifiez que vous pouvez écrire dans le nouveau Dataproc Metastore principal dans la région 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;"

Le résultat contient les éléments suivants :

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

Le basculement est maintenant terminé. Vous devez maintenant rediriger vos applications clientes vers le nouveau cluster Dataproc principal de la région B en mettant à jour les fichiers de configuration du client Hadoop.

Retour à la région d'origine

Cette section décrit la procédure à suivre pour revenir à la région d'origine (région A).

Dans Cloud Shell, exportez les métadonnées de l'instance DPMS:

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

Récupérez le chemin de la dernière sauvegarde de métadonnées:

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

Importez les métadonnées dans l'instance de DPMS de secours dans la région d'origine (région 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")

Vérifiez que les métadonnées ont été correctement importées:

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

Le résultat comprend les éléments suivants :

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

Les rôles de Metastore Dataproc principal et de secours sont à nouveau échangés.

Mettez à jour les variables d'environnement avec ces nouveaux rôles:

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

La restauration est maintenant terminée. Vous devez maintenant rediriger vos applications clientes vers le nouveau cluster Dataproc principal de la région A en mettant à jour les fichiers de configuration du client Hadoop.

Créer des sauvegardes automatiques de métadonnées

Cette section décrit deux méthodes différentes permettant d'automatiser les exportations et les importations de sauvegardes de métadonnées. La première méthode, Option 1 : Cloud Run et Cloud Scheduler, utilise Cloud Run et Cloud Scheduler. La deuxième méthode, Option 2: Cloud Composer, utilise Cloud Composer. Dans les deux exemples, une tâche d'exportation crée une sauvegarde des métadonnées à partir du DPMS principal dans la région A. Une tâche d'importation remplit le DPMS de secours de la région B à partir de la sauvegarde.

Si vous disposez déjà d'un cluster Cloud Composer, vous devez envisager l'option 2: Cloud Composer (en supposant que votre cluster dispose d'une capacité de calcul suffisante). Sinon, choisissez l'option 1: Cloud Run et Cloud Scheduler. Cette option utilise un modèle de tarification à l'utilisation et est plus économique que Cloud Composer, qui nécessite l'utilisation de ressources de calcul persistantes.

Option 1: Cloud Run et Cloud Scheduler

Cette section explique comment utiliser Cloud Run et Cloud Scheduler pour automatiser les exportations d'importations de métadonnées DPMS.

Services Cloud Run

Cette section explique comment créer deux services Cloud Run pour exécuter les tâches d'exportation et d'importation de métadonnées.

Dans Cloud Shell, activez Cloud Run. Cloud Scheduler Cloud Build, et App Engine API:
```
gcloud services enable run.googleapis.com cloudscheduler.googleapis.com cloudbuild.googleapis.com appengine.googleapis.com
```
Vous activez l'API App Engine, car le service Cloud Scheduler nécessite App Engine.

Créez l'image Docker avec le fichier Dockerfile fourni:

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

Déployez votre image de conteneur sur un service Cloud Run dans la région principale (région A). Ce déploiement est chargé de créer les sauvegardes de métadonnées à partir du métastore 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
```
Par défaut, une requête de service Cloud Run expire au bout de 5 minutes. Pour garantir que toutes les requêtes disposent de suffisamment de temps pour se terminer, l'exemple de code précédent étend la valeur du délai avant expiration à au moins 10 minutes.

Récupérez l'URL de déploiement pour le service 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}

Créez un deuxième service Cloud Run dans la région de secours (région B). Ce service est chargé d'importer les sauvegardes de métadonnées de BACKUP_BUCKET dans le métastore de secours:

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

Récupérez l'URL de déploiement pour le deuxième service 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}

Planification des tâches

Cette section explique comment utiliser Cloud Scheduler pour déclencher les deux services Cloud Run.

Dans Cloud Shell, créez une application App Engine, dont Cloud Scheduler a besoin:
```
gcloud app create --region=${REGION_A}
```

Créez une tâche Cloud Scheduler pour planifier les exportations de métadonnées à partir du métastore principal:

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

La tâche Cloud Scheduler envoie une requête http au service Cloud Run toutes les 15 minutes. La Le service Cloud Run exécute un pipeline Fiole une application avec une fonction d'exportation et d'importation. Lorsque la fonction d'exportation est déclenchée, elle exporte les métadonnées vers Cloud Storage à l'aide de la commande gcloud metastore services export.

En général, si vos tâches Hadoop écrivent fréquemment dans le métastore Hive, nous vous recommandons de sauvegarder régulièrement votre métastore. Un bon planning de sauvegarde est compris entre toutes les 15 et 60 minutes.

Déclenchez un test du service Cloud Run:
```
gcloud scheduler jobs run dpms-export
```
Vérifiez que Cloud Scheduler a correctement déclenché l'opération d'exportation DPMS:
```
gcloud metastore operations list --location ${REGION_A}
```
Le résultat se présente comme suit :
```
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
```
Si la valeur de DONE est False, l'exportation est toujours en cours. Pour confirmer que l'opération est terminée, exécutez à nouveau la commande gcloud metastore operations list --location ${REGION_A} jusqu'à ce que la valeur devienne True.

Pour en savoir plus sur les commandes gcloud metastore operations, consultez la documentation de référence.

(Facultatif) Créez une tâche Cloud Scheduler pour planifier les importations dans le métastore de secours:

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

Cette étape dépend de vos exigences d'objectif de temps de récupération (RTO).

Si vous souhaitez utiliser un secours à chaud (hot standby) pour minimiser votre temps de basculement, vous devez planifier cette tâche d'importation. Elle actualise vos DPMS de secours toutes les 15 minutes.

Si un système de secours à froid est suffisant pour vos besoins RTO, vous pouvez ignorer cette étape et supprimer également votre DPMS de secours et votre cluster Dataproc en vue de réduire votre facture mensuelle globale. Lorsque vous basculez vers votre région de secours (région B), provisionnez le DPMS de secours et le cluster Dataproc, puis exécutez une tâche d'importation. Étant donné que les fichiers de sauvegarde sont stockés dans un bucket birégional, ils sont accessibles même si votre région principale (région A) est défaillante.

Gérer les basculements

Une fois le basculement vers la région B effectué, vous devez appliquer les étapes suivantes pour préserver vos exigences de reprise après sinistre et protéger votre infrastructure contre une défaillance potentielle de la région B:

Mettez en veille vos tâches Cloud Scheduler existantes.
Remplacez la région DPMS principale par la région B (us-east1).
Remplacez la région DPMS de secours par la région A (us-central1).
Mettez à jour l'instance principale DPMS vers dpms2.
Mettez à jour l'instance de secours DPMS sur dpms1.
Redéployez les services Cloud Run en fonction des variables mises à jour.
Créez des tâches Cloud Scheduler pointant vers vos nouveaux services Cloud Run.

Les étapes requises dans la liste précédente répètent de nombreuses étapes des sections précédentes, avec seulement des ajustements mineurs (comme le remplacement des noms de régions). Utilisez les informations de l'option 1: Cloud Run et Cloud Scheduler pour effectuer ce travail.

Option 2: Cloud Composer

Cette section explique comment utiliser Cloud Composer pour exécuter des tâches d'exportation et d'importation au sein d'un seul graphe orienté acyclique (DAG) Airflow.

Dans Cloud Shell, activez l'API Cloud Composer :
```
gcloud services enable composer.googleapis.com
```
Créez un environnement 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
```
- L'image de composition composer-1.17.0-preview.1-airflow-2.0.1 correspond à la dernière version date de publication.
- Les environnements Composer ne peuvent utiliser qu'une seule version majeure de Python. Python 3 a été sélectionné, car Python 2 présente des problèmes de compatibilité.

Configurez votre environnement Cloud Composer avec les variables d'environnement suivantes:

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}

Importez le Fichier DAG à votre environnement Composer:

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

Récupérez l'URL Airflow:

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

Dans votre navigateur, ouvrez l'URL renvoyée par la commande précédente.

Une nouvelle entrée DAG appelée dpms_dag doit s'afficher. Lors d'une seule exécution, le DAG exécute une exportation, suivie d'une importation. Le DAG suppose que le DPMS de secours est toujours disponible. Si vous n'avez pas besoin de secours à chaud (hot standby) et que vous souhaitez seulement exécuter la tâche d'exportation, vous devez commenter toutes les tâches d'importation dans le code (find_backup, wait_for_ready_status, current_ts, dpms_import).
Cliquez sur l'icône représentant une flèche pour déclencher le DAG afin de lancer un test:
Cliquez sur Graph View (Vue graphique) du DAG en cours d'exécution pour vérifier l'état de chaque tâche:

Une fois le DAG validé, Airflow peut l'exécuter de manière régulière. La planification est définie sur un intervalle de 30 minutes, mais vous pouvez le modifier en modifiant le paramètre schedule_interval dans le code pour répondre à vos exigences.

Gérer les basculements

Remplacez la région DPMS principale par la région B (us-east1).
Remplacez la région DPMS de secours par la région A (us-central1).
Mettez à jour l'instance principale DPMS vers dpms2.
Mettez à jour l'instance de secours DPMS sur dpms1.
Créez un environnement Cloud Composer dans la région B (us-east1).
Configurez l'environnement Cloud Composer avec les variables d'environnement mises à jour.
Importez le même DAG Airflow dpms_dag que précédemment dans votre nouvel environnement Cloud Composer.

Les étapes requises dans la liste précédente répètent de nombreuses étapes des sections précédentes, avec seulement des ajustements mineurs (comme le remplacement des noms de régions). Utilisez les informations de l'option 2: Cloud Composer pour effectuer ce travail requis.

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Étape suivante

Découvrez comment surveiller votre instance Dataproc Metastore.
Découvrez comment synchroniser votre métastore Hive avec Data Catalog.
En savoir plus sur en cours de développement Services Cloud Run
Pour découvrir d'autres architectures de référence, schémas et bonnes pratiques, consultez le Centre d'architecture cloud.