Ir a la consola

Programa exportaciones de datos

En esta página, se describe cómo programar las exportaciones de tus datos de Cloud Firestore. Para ejecutar exportaciones programadas, te recomendamos implementar un servicio de App Engine que llame a la función de exportación administrada de Cloud Firestore. Después de implementarlo, puedes programar llamadas a él con el servicio de cron de App Engine.

Antes de comenzar

Antes de programar exportaciones de datos con la función administrada, debes completar las siguientes tareas:

  1. Habilita la facturación para tu proyecto de Google Cloud Platform. Solo los proyectos de GCP que tengan la facturación habilitada pueden usar la función de importación y exportación.
  2. Crea un depósito de Cloud Storage para tu proyecto en una ubicación cercana a la base de datos de Cloud Firestore. No puedes usar un depósito de pagos del solicitante para las operaciones de importación y exportación.
  3. Instala el SDK de Google Cloud para otorgar permisos de acceso y, también, implementar la aplicación.

Configura los permisos de acceso

La app usa la cuenta de servicio predeterminada de App Engine para autenticar y autorizar las operaciones de exportación. Cuando creas un proyecto, se crea para ti la cuenta de servicio predeterminada con el siguiente formato:

YOUR_PROJECT_ID@appspot.gserviceaccount.com

La cuenta de servicio requiere permisos para iniciar operaciones de exportación y escribir en el depósito de Cloud Storage. A fin de otorgar esos permisos, asigna las siguientes funciones de IAM a la cuenta de servicio predeterminada:

  • Cloud Datastore Import Export Admin
  • Funciones Owner o Storage Admin en el depósito

Puedes usar las herramientas de línea de comandos de gcloud y gsutil del SDK de Google Cloud para asignar estas funciones:

  1. Asigna la función Administrador de importación y exportación de Cloud Datastore:

    gcloud projects add-iam-policy-binding YOUR_PROJECT_ID \
        --member serviceAccount:YOUR_PROJECT_ID@appspot.gserviceaccount.com \
        --role roles/datastore.importExportAdmin
    
  2. Asigna la función Administrador de almacenamiento en tu depósito:

    gsutil iam ch serviceAccount:YOUR_PROJECT_ID@appspot.gserviceaccount.com:storage.admin \
        gs://BUCKET_NAME
    

Archivos de aplicación

En una carpeta nueva, crea los siguientes archivos de aplicación con este código:

app.yaml
Configura el entorno de ejecución de App Engine. La app usa el entorno de ejecución estándar de un entorno Node.js.
app.js
Es el código de la app principal que configura un servicio web en https://YOUR_PROJECT_ID.appspot.com para iniciar las operaciones de exportación.
package.json
Incluye información sobre la app y sus dependencias.
cron.yaml
Configura un trabajo cron que llama al servicio web.

app.yaml

runtime: nodejs8

El código anterior supone que esta app es la predeterminada. Si no lo es, agrega la siguiente línea:

target: cloud-firestore-admin

app.js

const axios = require('axios');
const dateformat = require('dateformat');
const express = require('express');
const { google } = require('googleapis');

const app = express();

// Trigger a backup
app.get('/cloud-firestore-export', async (req, res) => {
  const auth = await google.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/datastore']
  });

  const accessTokenResponse = await auth.getAccessToken();
  const accessToken = accessTokenResponse.token;

  const headers = {
    'Content-Type': 'application/json',
    Authorization: 'Bearer ' + accessToken
  };

  const outputUriPrefix = req.param('outputUriPrefix');
  if (!(outputUriPrefix && outputUriPrefix.indexOf('gs://') == 0)) {
    res.status(500).send(`Malformed outputUriPrefix: ${outputUriPrefix}`);
  }

  // Construct a backup path folder based on the timestamp
  const timestamp = dateformat(Date.now(), 'yyyy-mm-dd-HH-MM-ss');
  let path = outputUriPrefix;
  if (path.endsWith('/')) {
    path += timestamp;
  } else {
    path += '/' + timestamp;
  }

  const body = {
    outputUriPrefix: path
  };

  // If specified, mark specific collections for backup
  const collectionParam = req.param('collections');
  if (collectionParam) {
    body.collectionIds = collectionParam.split(',');
  }

  const projectId = process.env.GOOGLE_CLOUD_PROJECT;
  const url = `https://firestore.googleapis.com/v1beta1/projects/${projectId}/databases/(default):exportDocuments`;

  try {
    const response = await axios.post(url, body, { headers: headers });
    res
      .status(200)
      .send(response.data)
      .end();
  } catch (e) {
    if (e.response) {
      console.warn(e.response.data);
    }

    res
      .status(500)
      .send('Could not start backup: ' + e)
      .end();
  }
});

// Index page, just to make it easy to see if the app is working.
app.get('/', (req, res) => {
  res
    .status(200)
    .send('[scheduled-backups]: Hello, world!')
    .end();
});

// Start the server
const PORT = process.env.PORT || 6060;
app.listen(PORT, () => {
  console.log(`App listening on port ${PORT}`);
  console.log('Press Ctrl+C to quit.');
});

package.json

{
  "name": "solution-scheduled-backups",
  "version": "1.0.0",
  "description": "Scheduled Cloud Firestore backups via AppEngine cron",
  "main": "app.js",
  "engines": {
    "node": "8.x.x"
  },
  "scripts": {
    "deploy": "gcloud app deploy --quiet app.yaml cron.yaml",
    "start": "node app.js"
  },
  "author": "Google, Inc.",
  "license": "Apache-2.0",
  "dependencies": {
    "axios": "^0.18.0",
    "dateformat": "^3.0.3",
    "express": "^4.16.4",
    "googleapis": "^38.0.0"
  },
  "devDependencies": {
    "prettier": "^1.16.4"
  }
}

cron.yaml

cron:
- description: "Daily Cloud Firestore Export"
  url: /cloud-firestore-export?outputUriPrefix=gs://BUCKET_NAME[/PATH]&collections=test1,test2
  target: cloud-firestore-admin
  schedule: every 24 hours

Para configurar la operación de exportación, modifica la línea de url. La app configura un servicio en https://YOUR_PROJECT_ID.appspot.com/cloud-firestore-export que acepta los siguientes parámetros de URL:

outputUriPrefix
Es la ubicación del depósito de Cloud Storage con el formato gs://BUCKET_NAME.
collections
Es una lista separada por comas de los ID de colección que se deben exportar. Si no se especifica, la operación exporta todas las colecciones.

Por ejemplo, para exportar todas las colecciones con los ID de colección Songs o Albums, debes usar lo siguiente:

url: /cloud-firestore-export?outputUriPrefix=gs://BUCKET_NAME&collections=Songs,Albums

El cron.yaml de ejemplo ejecuta una exportación cada 24 horas. Para ver otras opciones de programación, consulta el formato de programación.

Implementa la app y el trabajo cron

Usa gcloud para implementar la app y el trabajo cron:

gcloud app deploy app.yaml cron.yaml

Prueba el trabajo cron

Si quieres probar el trabajo cron implementado, inícialo en la página Trabajos cron de Google Cloud Platform Console.

  1. Abre la página Trabajos cron en GCP Console.
    Abrir la página Trabajos cron

  2. Busca el trabajo cron con la descripción Exportación diaria de Cloud Firestore y haz clic en Ejecutar ahora.

  3. Después de que finalice el trabajo, revisa el mensaje que aparece en Estado. Haz clic en Ver para revisar el registro del trabajo. El mensaje de estado y el registro del trabajo informan si este se realizó correctamente.

Consulta las exportaciones

Una vez que se completen las operaciones de exportación, puedes verlas en el depósito de Cloud Storage. Para ello, realiza lo siguiente:

Abre el navegador de Cloud Storage en GCP Console.
Abrir el navegador de Cloud Storage