Esta página se ha traducido con Cloud Translation API.

Recuperación tras desastres de Dataproc Metastore

Dataproc Metastore

En este tutorial se propone una estrategia de recuperación tras fallos y continuidad empresarial en dos regiones con Dataproc Metastore. En el tutorial se usan contenedores de doble región para almacenar tanto conjuntos de datos de Hive como exportaciones de metadatos de Hive.

Dataproc Metastore es un servicio de almacén de metadatos totalmente gestionado, de alta disponibilidad, con escalado automático, recuperación automática y nativo de OSS que simplifica enormemente la gestión de metadatos técnicos. Nuestro servicio gestionado se basa en Apache Hive Metastore y es un componente fundamental para los lagos de datos empresariales.

Este tutorial está dirigido a Google Cloud clientes que necesitan alta disponibilidad para sus datos y metadatos de Hive. Usa Cloud Storage para el almacenamiento, Dataproc para la computación y Dataproc Metastore (DPMS), un servicio de Hive Metastore totalmente gestionado en Google Cloud. En el tutorial también se muestran dos formas diferentes de orquestar las conmutaciones por error: una usa Cloud Run y Cloud Scheduler, y la otra usa Cloud Composer.

El enfoque de doble región que se usa en el tutorial tiene ventajas e inconvenientes:

Ventajas

Los segmentos birregionales tienen redundancia geográfica.
Los contenedores de dos regiones tienen un acuerdo de nivel de servicio con una disponibilidad del 99,95 %, frente al 99,9% de los contenedores de una sola región.
Los segmentos birregionales tienen un rendimiento optimizado en dos regiones, mientras que los segmentos de una sola región no funcionan tan bien cuando se trabaja con recursos de otras regiones.

Desventajas

Las escrituras en segmentos birregionales no se replican inmediatamente en ambas regiones.
Los segmentos de dos regiones tienen costes de almacenamiento más altos que los segmentos de una sola región.

Arquitectura de referencia

En los siguientes diagramas de arquitectura se muestran los componentes que se usan en este tutorial. En ambos diagramas, la X roja grande indica que la región principal no funciona:

Usar Cloud Run y Cloud Scheduler para conmutar por error de una región principal a una secundaria. Ilustración 1: Uso de Cloud Run y Cloud Scheduler

Usar Cloud Composer para conmutar por error de una región principal a una secundaria. Figura 2: Uso de Cloud Composer

Los componentes de la solución y sus relaciones son los siguientes:

Dos segmentos de Cloud Storage de dos regiones: crea un segmento para los datos de Hive y otro para las copias de seguridad periódicas de los metadatos de Hive. Crea ambos cubos birregionales de forma que usen las mismas regiones que los clústeres de Hadoop que acceden a los datos.
Un almacén de metadatos de Hive que usa DPMS: este almacén de metadatos de Hive se crea en la región principal (región A). La configuración del metastore apunta a tu segmento de datos de Hive. Un clúster de Hadoop que use Dataproc debe estar en la misma región que la instancia de DPMS a la que esté conectado.
Una segunda instancia de DPMS: creas una segunda instancia de DPMS en tu región de espera (región B) para prepararte ante un fallo en toda la región. A continuación, importa el archivo de exportación hive.sql más reciente de tu contenedor de exportación a tu DPMS de reserva. También puedes crear un clúster de Dataproc en tu región de espera y adjuntarlo a tu instancia de DPMS de espera. Por último, en un escenario de recuperación ante desastres, rediriges tus aplicaciones cliente desde tu clúster de Dataproc de la región A a tu clúster de Dataproc de la región B.
Un despliegue de Cloud Run: creas un despliegue de Cloud Run en la región A que exporta periódicamente los metadatos de DPMS a un segmento de copia de seguridad de metadatos mediante Cloud Scheduler (como se muestra en la figura 1). La exportación se realiza en forma de archivo SQL que contiene un volcado completo de los metadatos de DPMS.

Nota: Cloud Scheduler depende de App Engine. Por lo tanto, solo se puede configurar para una región por proyecto. Google Cloud Por lo tanto, usa Cloud Scheduler solo en situaciones de recuperación ante desastres a corto plazo en las que la duración de la conmutación por error a la región B se mida en horas o días, en lugar de semanas o meses.

Si ya tiene un entorno de Cloud Composer, puede orquestar las exportaciones e importaciones de metadatos de DPMS ejecutando un DAG de Airflow en ese entorno (como se muestra en la figura 2). Este uso de un DAG de Airflow sustituiría al método de Cloud Run mencionado anteriormente.

Crear almacenamiento para datos de Hive y copias de seguridad de Hive Metastore

En esta sección, crearás segmentos de Cloud Storage para alojar los datos de Hive y las copias de seguridad de Hive Metastore.

Crear un almacenamiento de datos de Hive

En Cloud Shell, crea un segmento birregional para alojar los datos de Hive:

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

Copia algunos datos de muestra en el segmento de datos de Hive:

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

Crear almacenamiento para copias de seguridad de metadatos

En Cloud Shell, crea un segmento birregional para alojar las copias de seguridad de los metadatos de DPMS:
```
gcloud storage buckets create gs://${BACKUP_BUCKET} --location=NAM4
```

Desplegar recursos de computación en la región principal

En esta sección, desplegará todos los recursos de computación en la región principal, incluida la instancia de DPMS y el clúster de Dataproc. También puedes rellenar Dataproc Metastore con metadatos de ejemplo.

Crear la instancia de DPMS

En Cloud Shell, crea la instancia de DPMS:
```
gcloud metastore services create ${DPMS_PRIMARY_INSTANCE} \
    --location=${DPMS_PRIMARY_REGION} \
    --hive-metastore-version=3.1.2
```
Este comando puede tardar varios minutos en completarse.

Nota: La versión 3.1.2 de Hive Metastore es compatible con la versión 2.0 de la imagen de Dataproc. Ambos usan la versión 3.1.2 de Hive. Si usas una versión diferente de Hive Metastore, asegúrate de usar una imagen de Dataproc compatible con la versión de Hive.

Define el segmento de datos de Hive como el directorio predeterminado del almacén:

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

Este comando puede tardar varios minutos en completarse.

Crear una agrupación Dataproc

En Cloud Shell, crea un clúster de Dataproc y adjúntalo a la instancia de 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

Especifica la imagen del clúster como versión 2.0, que es la versión más reciente disponible desde junio del 2021. También es la primera versión compatible con DPMS.

Rellenar el metastore

En Cloud Shell, actualiza el ejemplo retail.hql proporcionado en el repositorio de este tutorial con el nombre del segmento de datos de Hive:
```
sed -i -- 's/${WAREHOUSE_BUCKET}/'"$WAREHOUSE_BUCKET"'/g' retail.hql
```

Ejecuta las consultas incluidas en el archivo retail.hql para crear las definiciones de tabla en el metastore:

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

Comprueba que las definiciones de tabla se hayan creado correctamente:

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

La salida es similar a la siguiente:

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

El resultado también contiene el número de elementos de cada tabla. Por ejemplo:

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

Conmutación por error a la región de espera

En esta sección se indican los pasos para conmutar por error de la región principal (región A) a la de espera (región B).

En Cloud Shell, exporta los metadatos de la instancia de DPMS principal al segmento de copias de seguridad:

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

La salida es similar a la siguiente:

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

Anote el valor del atributo destinationGcsUri. Este atributo almacena la copia de seguridad que has creado.

Crea una instancia de DPMS en la región de espera:

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

Define el segmento de datos de Hive como el directorio predeterminado del almacén:

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

Recupera la ruta de la copia de seguridad de metadatos más reciente:

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

Importa los metadatos de los que has creado una copia de seguridad en la nueva instancia de 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")

Crea un clúster de Dataproc en la región de espera (región 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

Comprueba que los metadatos se hayan importado correctamente:
```
gcloud dataproc jobs submit hive \
    --cluster ${HADOOP_STANDBY} \
    --region ${DPMS_STANDBY_REGION} \
    --execute "select count(*) as num_orders from orders;"
```
El num_ordersresultado es lo más importante del tutorial. Se parece a lo siguiente:
```
+-------------+
| num_orders  |
+-------------+
| 68883       |
+-------------+
```
El metastore principal de Dataproc se ha convertido en el nuevo metastore de reserva, y el metastore de reserva de Dataproc se ha convertido en el nuevo metastore principal.

Actualiza las variables de entorno en función de estos nuevos roles:

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

Verifica que puedes escribir en el nuevo Dataproc Metastore principal de la región 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;"

La salida contiene lo siguiente:

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

La conmutación por error se ha completado. Ahora debes redirigir tus aplicaciones cliente al nuevo clúster principal de Dataproc de la región B actualizando los archivos de configuración del cliente de Hadoop.

Volver a la región original

En esta sección se indican los pasos para volver a la región original (región A).

En Cloud Shell, exporta los metadatos de la instancia de DPMS:

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

Recupera la ruta de la copia de seguridad de metadatos más reciente:

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

Importa los metadatos a la instancia de DPMS de espera de la región original (región 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")

Comprueba que los metadatos se hayan importado correctamente:

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

La salida incluye lo siguiente:

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

El Dataproc Metastore principal y el de reserva han vuelto a intercambiar sus roles.

Actualiza las variables de entorno con estos nuevos roles:

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 conmutación por recuperación se ha completado. Ahora debes redirigir tus aplicaciones cliente al nuevo clúster principal de Dataproc de la región A actualizando los archivos de configuración del cliente de Hadoop.

Crear copias de seguridad de metadatos automatizadas

En esta sección se describen dos métodos diferentes para automatizar las exportaciones e importaciones de copias de seguridad de metadatos. El primer método, Opción 1: Cloud Run y Cloud Scheduler, usa Cloud Run y Cloud Scheduler. El segundo método, Opción 2: Cloud Composer, utiliza Cloud Composer. En ambos ejemplos, una tarea de exportación crea una copia de seguridad de los metadatos del DPMS principal de la región A. Una tarea de importación rellena el DPMS de espera de la región B a partir de la copia de seguridad.

Si ya tienes un clúster de Cloud Composer, te recomendamos que elijas la opción 2: Cloud Composer (siempre que tu clúster tenga suficiente capacidad de computación). De lo contrario, elige la opción 1: Cloud Run y Cloud Scheduler. Esta opción usa un modelo de precios de pago por uso y es más económica que Cloud Composer, que requiere el uso de recursos de computación persistentes.

Opción 1: Cloud Run y Cloud Scheduler

En esta sección se muestra cómo usar Cloud Run y Cloud Scheduler para automatizar las exportaciones e importaciones de metadatos de DPMS.

Servicios de Cloud Run

En esta sección se muestra cómo crear dos servicios de Cloud Run para ejecutar las tareas de exportación e importación de metadatos.

En Cloud Shell, habilita las APIs Cloud Run, Cloud Scheduler, Cloud Build y App Engine:
```
gcloud services enable run.googleapis.com cloudscheduler.googleapis.com cloudbuild.googleapis.com appengine.googleapis.com
```
Habilita la API App Engine porque el servicio Cloud Scheduler requiere App Engine.

Compila la imagen Docker con el Dockerfile proporcionado:

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

Despliega la imagen de contenedor en un servicio de Cloud Run de la región principal (región A). Esta implementación se encarga de crear las copias de seguridad de los metadatos del 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
```
De forma predeterminada, las solicitudes de servicio de Cloud Run agotan el tiempo de espera después de 5 minutos. Para asegurarse de que todas las solicitudes tengan tiempo suficiente para completarse correctamente, el ejemplo de código anterior amplía el valor de tiempo de espera a 10 minutos como mínimo.

Recupera la URL de implementación del servicio de 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}

Crea un segundo servicio de Cloud Run en la región de espera (región B). Este servicio se encarga de importar las copias de seguridad de los metadatos de BACKUP_BUCKET al metastore de reserva:

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

Obtén la URL de implementación del segundo servicio de 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}

Programación de tareas

En esta sección se muestra cómo usar Cloud Scheduler para activar los dos servicios de Cloud Run.

En Cloud Shell, crea una aplicación de App Engine, que es necesaria para Cloud Scheduler:
```
gcloud app create --region=${REGION_A}
```

Crea una tarea de Cloud Scheduler para programar las exportaciones de metadatos del metastore principal:

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

La tarea de Cloud Scheduler envía una solicitud http al servicio de Cloud Run cada 15 minutos. El servicio Cloud Run ejecuta una aplicación Flask en un contenedor con funciones de exportación e importación. Cuando se activa la función de exportación, se exportan los metadatos a Cloud Storage mediante el comando gcloud metastore services export.

En general, si tus tareas de Hadoop escriben con frecuencia en el metastore de Hive, te recomendamos que hagas copias de seguridad del metastore a menudo. Una buena programación de copias de seguridad sería de entre 15 y 60 minutos.

Activa una ejecución de prueba del servicio de Cloud Run:
```
gcloud scheduler jobs run dpms-export
```
Verifica que Cloud Scheduler haya activado correctamente la operación de exportación de DPMS:
```
gcloud metastore operations list --location ${REGION_A}
```
La salida es similar a la siguiente:
```
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 el valor de DONE es False, la exportación aún está en curso. Para confirmar que la operación se ha completado, vuelve a ejecutar el comando gcloud metastore operations list --location ${REGION_A} hasta que el valor sea True.

Consulta más información sobre los comandos gcloud metastore operations en la documentación de referencia.

(Opcional) Crea una tarea de Cloud Scheduler para programar las importaciones en el metastore de reserva:

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

Este paso depende de los requisitos de tu objetivo de tiempo de recuperación (RTO).

Si quieres que haya una instancia en espera activa para minimizar el tiempo de conmutación por error, debes programar esta tarea de importación. Actualiza tu DPMS en modo de espera cada 15 minutos.

Si una réplica de reserva inactiva es suficiente para tus necesidades de tiempo de inactividad, puedes omitir este paso y eliminar tu DPMS de reserva y tu clúster de Dataproc para reducir aún más tu factura mensual general. Cuando se produzca una conmutación por error a tu región de espera (región B), aprovisiona el DPMS de espera y el clúster de Dataproc, y ejecuta una tarea de importación. Como los archivos de copia de seguridad se almacenan en un segmento birregional, se puede acceder a ellos aunque tu región principal (región A) deje de funcionar.

Gestionar conmutaciones por error

Una vez que hayas cambiado a la región B, debes seguir estos pasos para mantener tus requisitos de recuperación tras desastres y proteger tu infraestructura frente a un posible fallo en la región B:

Pausa las tareas de Cloud Scheduler que ya tengas.
Actualiza la región DPMS de la primaria a la región B (us-east1).
Actualiza la región DPMS de la instancia en espera a la región A (us-central1).
Actualiza la instancia principal de DPMS a dpms2.
Actualiza la instancia de espera de DPMS a dpms1.
Vuelve a desplegar los servicios de Cloud Run en función de las variables actualizadas.
Crea tareas de Cloud Scheduler que apunten a tus nuevos servicios de Cloud Run.

Los pasos necesarios en la lista anterior repiten muchos de los pasos de las secciones anteriores, solo con pequeños ajustes (como cambiar los nombres de las regiones). Usa la información de la sección Opción 1: Cloud Run y Cloud Scheduler para completar esta tarea obligatoria.

Opción 2: Cloud Composer

En esta sección se muestra cómo usar Cloud Composer para ejecutar las tareas de exportación e importación en un solo Airflow.

En Cloud Shell, habilita la API de Cloud Composer:
```
gcloud services enable composer.googleapis.com
```
Crea un entorno de 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
```
- La imagen de Composer composer-1.17.0-preview.1-airflow-2.0.1 es la versión más reciente en el momento de la publicación.
- Los entornos de Composer solo pueden usar una versión principal de Python. Se ha seleccionado Python 3 porque Python 2 tiene problemas de compatibilidad.

Configura tu entorno de Cloud Composer con estas variables de entorno:

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}

Sube el archivo DAG a tu entorno de Composer:

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

Obtén la URL de Airflow:

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

En el navegador, abre la URL devuelta por el comando anterior.

Debería ver una nueva entrada de DAG llamada dpms_dag. En una sola ejecución, el DAG ejecuta una exportación y, a continuación, una importación. El DAG da por hecho que el DPMS en espera siempre está activo. Si no necesitas una copia de seguridad activa y solo quieres ejecutar la tarea de exportación, debes comentar todas las tareas relacionadas con la importación en el código (find_backup, wait_for_ready_status, current_ts, dpms_import).
Haz clic en el icono de la flecha para activar el DAG y hacer una prueba:
Haga clic en Vista de gráfico del DAG en ejecución para comprobar el estado de cada tarea:

Una vez que haya validado el DAG, deje que Airflow lo ejecute de forma periódica. La programación se establece en un intervalo de 30 minutos, pero se puede ajustar cambiando el parámetro schedule_interval del código para que se adapte a tus requisitos de tiempo.

Gestionar conmutaciones por error

Actualiza la región DPMS de la primaria a la región B (us-east1).
Actualiza la región DPMS de la instancia en espera a la región A (us-central1).
Actualiza la instancia principal de DPMS a dpms2.
Actualiza la instancia de espera de DPMS a dpms1.
Crea un entorno de Cloud Composer en la región B (us-east1).
Configura el entorno de Cloud Composer con las variables de entorno actualizadas.
Importa el mismo dpms_dag DAG de Airflow que antes a tu nuevo entorno de Cloud Composer.

Los pasos necesarios en la lista anterior repiten muchos de los pasos de las secciones anteriores, solo con pequeños ajustes (como cambiar los nombres de las regiones). Usa la información de la opción 2: Cloud Composer para completar este paso obligatorio.

Recuperación tras desastres de Dataproc Metastore Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Arquitectura de referencia

Crear almacenamiento para datos de Hive y copias de seguridad de Hive Metastore

Crear un almacenamiento de datos de Hive

Crear almacenamiento para copias de seguridad de metadatos

Desplegar recursos de computación en la región principal

Crear la instancia de DPMS

Crear una agrupación Dataproc

Rellenar el metastore

Conmutación por error a la región de espera

Volver a la región original

Crear copias de seguridad de metadatos automatizadas

Opción 1: Cloud Run y Cloud Scheduler

Servicios de Cloud Run

Programación de tareas

Gestionar conmutaciones por error

Opción 2: Cloud Composer

Gestionar conmutaciones por error

Recuperación tras desastres de Dataproc Metastore