Mit Firebase im Cache speichern

Data Studio hat ein eigenes Cachesystem für Berichte. Wenn Sie einen Connector erstellen, können Sie einen benutzerdefinierten Cache implementieren, um Berichte schneller zu erstellen und Ratenlimits für APIs zu vermeiden.

Angenommen, Sie erstellen einen Connector, der historische Wetterdaten für die letzten 7 Tage für eine bestimmte Postleitzahl bereitstellt. Ihr Connector wird immer beliebter, aber die externe API, von der Sie die Daten abrufen, hat strenge Ratenlimits. Die API aktualisiert ihre Daten nur täglich. Für eine bestimmte Postleitzahl ist es also nicht erforderlich, dieselben Daten mehrmals am Tag abzurufen. Mit diesem Lösungsleitfaden können Sie einen täglichen Cache für jede Postleitzahl implementieren.

Voraussetzungen

Eine Firebase Realtime Database. Wenn Sie keinen Zugriff darauf haben, erstellen Sie ein Google Cloud Platform-Projekt (GCP) und folgen Sie der Anleitung für den Einstände, um eine eigene Firebase Realtime Database-Instanz zu erstellen.
Ein GCP-Dienstkonto zum Lesen und Schreiben von Daten aus der Firebase Realtime Database.
Ein Community-Connector, der Daten aus einer Quelle abruft.

Beschränkungen

Diese Lösung kann nicht mit [Data Studio Advanced Services] verwendet werden. Wenn Sie Data Studio Advanced Services verwenden, hat Ihr Connector-Code in Apps Script keinen Zugriff auf die Daten. Daher können Sie die Daten nicht mit Apps Script im Cache speichern.
Berichtseditoren und ‑betrachter können diesen Cache nicht zurücksetzen.

Lösung

Dienstkonto implementieren

Erstellen Sie ein Dienstkonto in Ihrem Google Cloud-Projekt.
Dieses Dienstkonto muss im Cloud-Projekt Zugriff auf BigQuery haben.
- Erforderliche IAM-Rollen (Identity and Access Management, Identitäts- und Zugriffsverwaltung): Firebase Admin
Laden Sie die JSON-Datei herunter, um die Schlüssel des Dienstkontos zu erhalten. Speichern Sie den Inhalt der Datei in den Skripteigenschaften Ihres Connector-Projekts. Nach dem Hinzufügen der Schlüssel sollte es in der Apps Script-UI so aussehen:
Fügen Sie Ihrem Apps Script-Projekt die OAuth2 for Apps Script-Bibliothek hinzu.
Implementieren Sie den erforderlichen OAuth2-Code für das Dienstkonto:

firestore-cache/src/firebase.js

Auf GitHub ansehen

var SERVICE_ACCOUNT_CREDS = 'SERVICE_ACCOUNT_CREDS';
var SERVICE_ACCOUNT_KEY = 'private_key';
var SERVICE_ACCOUNT_EMAIL = 'client_email';
var BILLING_PROJECT_ID = 'project_id';

var scriptProperties = PropertiesService.getScriptProperties();

/**
 * Copy the entire credentials JSON file from creating a service account in GCP.
 * Service account should have `Firebase Admin` IAM role.
 */
function getServiceAccountCreds() {
  return JSON.parse(scriptProperties.getProperty(SERVICE_ACCOUNT_CREDS));
}

function getOauthService() {
  var serviceAccountCreds = getServiceAccountCreds();
  var serviceAccountKey = serviceAccountCreds[SERVICE_ACCOUNT_KEY];
  var serviceAccountEmail = serviceAccountCreds[SERVICE_ACCOUNT_EMAIL];

  return OAuth2.createService('FirebaseCache')
    .setAuthorizationBaseUrl('https://accounts.google.com/o/oauth2/auth')
    .setTokenUrl('https://accounts.google.com/o/oauth2/token')
    .setPrivateKey(serviceAccountKey)
    .setIssuer(serviceAccountEmail)
    .setPropertyStore(scriptProperties)
    .setCache(CacheService.getScriptCache())
    .setScope([
      'https://www.googleapis.com/auth/userinfo.email',
      'https://www.googleapis.com/auth/firebase.database'
    ]);
}

Code zum Lesen und Schreiben in Firebase implementieren

Sie verwenden die Firebase Database REST API, um Daten in einer Firebase Realtime Database zu lesen und zu schreiben. Der folgende Code implementiert die Methoden, die für den Zugriff auf diese API erforderlich sind.

getData() implementieren

Die Struktur für Ihren vorhandenen getData()-Code ohne Caching sollte so aussehen:

firestore-cache/src/without-caching.js

Auf GitHub ansehen

/*
 * This file is only to demonstrate how the `getData()` fucntion would look
 * like without the Firebase Realtime Database caching. It is not a part of
 * the connector code and should not be included in Apps Script / Clasp.
 */

function getData(request) {
  var requestedFields = getFields().forIds(
    request.fields.map(function(field) {
      return field.name;
    })
  );

  var fetchedData = fetchAndParseData(request);
  var data = getFormattedData(fetchedData, requestedFields);

  return {
    schema: requestedFields.build(),
    rows: data
  };
}

So verwenden Sie Caching in Ihrem getData()-Code:

Bestimmen Sie den „Chunk“ oder die „Einheit“ der Daten, die im Cache gespeichert werden sollen.
Erstellen Sie einen eindeutigen Schlüssel, um die kleinste Dateneinheit im Cache zu speichern.
Für die Beispielimplementierung wird zipcode aus configparams als Schlüssel verwendet.
Optional: Für einen Cache pro Nutzer erstellen Sie einen zusammengesetzten Schlüssel mit dem Basisschlüssel und Nutzeridentität. Beispielimplementierung:
js var baseKey = getBaseKey(request); var userEmail = Session.getEffectiveUser().getEmail(); var hasheduserEmail = getHashedValue(userEmail); var compositeKey = baseKey + hasheduserEmail;
Wenn Daten im Cache vorhanden sind, prüfen Sie, ob der Cache aktuell ist.
Im Beispiel werden die Daten im Cache für eine bestimmte Postleitzahl mit dem aktuellen Datum gespeichert. Wenn Daten aus dem Cache abgerufen werden, wird das Datum für den Cache mit dem aktuellen Datum verglichen.
```
var cacheForZipcode = {
  data: <data being cached>,
  ymd: <current date in YYYYMMDD format>
}
```
Wenn keine Daten im Cache vorhanden sind oder die Daten im Cache nicht aktuell sind, rufen Sie die Daten aus der Quelle ab und speichern Sie sie im Cache.

Im folgenden Beispiel enthält main.js den getData()-Code mit implementiertem Caching.

Beispielcode

Hier sehen Sie ein vollständiges Beispiel für einen Connector, der Firebase für das Caching verwendet:

main.js

firestore-cache/src/main.js

Auf GitHub ansehen

// [start common_connector_code]
var cc = DataStudioApp.createCommunityConnector();

function getAuthType() {
  return cc
    .newAuthTypeResponse()
    .setAuthType(cc.AuthType.NONE)
    .build();
}

function getConfig(request) {
  var config = cc.getConfig();

  config
    .newTextInput()
    .setId('zipcode')
    .setName('Enter Zip Code')
    .setPlaceholder('eg. 95054');

  return config.build();
}

function getFields() {
  var fields = cc.getFields();
  var types = cc.FieldType;
  var aggregations = cc.AggregationType;

  fields
    .newDimension()
    .setId('zipcode')
    .setName('Zip code')
    .setType(types.TEXT);

  fields
    .newDimension()
    .setId('date')
    .setName('Date')
    .setType(types.YEAR_MONTH_DAY);

  fields
    .newMetric()
    .setId('temperature')
    .setName('Temperature (F)')
    .setType(types.NUMBER)
    .setIsReaggregatable(false);

  return fields;
}

function getSchema(request) {
  return {
    schema: getFields().build()
  };
}
// [end common_connector_code]

// [start caching_implementation]
function getData(request) {
  var requestedFields = getFields().forIds(
    request.fields.map(function(field) {
      return field.name;
    })
  );

  var cacheUpdateNeeded = true;
  var url = buildFirebaseUrl(request.configParams.zipcode);
  var cache = firebaseCache('get', url);

  if (cache) {
    var currentYmd = getCurrentYmd();
    cacheUpdateNeeded = currentYmd > cache.ymd;
  }

  if (cacheUpdateNeeded) {
    var fetchedData = fetchAndParseData(request);
    cache = {};
    cache.data = fetchedData;
    cache.ymd = currentYmd;
    firebaseCache('delete', url);
    firebaseCache('post', url, cache);
  }

  var data = getFormattedData(cache.data, requestedFields);

  var requestedFields = getFields().forIds(
    request.fields.map(function(field) {
      return field.name;
    })
  );

  var cache = getCachedData(request);
  var data = getFormattedData(cache, requestedFields);

  return {
    schema: requestedFields.build(),
    rows: data
  };
}

function getCachedData(request) {
  var cacheUpdateNeeded = true;
  var url = buildFirebaseUrl(request.configParams.zipcode);
  var cachedData = getFromCache(url);
  var currentYmd = getCurrentYmd();

  if (cachedData) {
    cacheUpdateNeeded = currentYmd > cachedData.ymd;
  }

  if (cacheUpdateNeeded) {
    var fetchedData = fetchAndParseData(request);
    freshData = {};
    freshData.data = fetchedData;
    freshData.ymd = currentYmd;
    deleteFromCache(url);
    putInCache(url, freshData);
    cachedData = freshData;
  }

  return cachedData.data;
}

function getCurrentYmd() {
  var currentDate = new Date();
  var year = currentDate.getFullYear();
  var month = ('0' + (currentDate.getMonth() + 1)).slice(-2);
  var date = ('0' + currentDate.getDate()).slice(-2);
  var currentYmd = year + month + date;
  return currentYmd;
}

// [end caching_implementation]

// [start common_getdata_implementation]
function fetchAndParseData(request) {
  // TODO: Connect to your own API endpoint and parse the fetched data.
  // To keep this example simple, we are returning dummy data instead of
  // connecting to an enpoint. This does not affect the caching.
  var parsedData = sampleData;
  return parsedData;
}

function getFormattedData(fetchedData, requestedFields) {
  var data = fetchedData.map(function(rowData) {
    return formatData(rowData, requestedFields);
  });
  return data;
}

function formatData(rowData, requestedFields) {
  var row = requestedFields.asArray().map(function(requestedField) {
    switch (requestedField.getId()) {
      case 'date':
        return rowData.date;
      case 'zipcode':
        return rowData.zipcode;
      case 'temperature':
        return rowData.temperature;
      default:
        return '';
    }
  });
  return {values: row};
}
// [end common_getdata_implementation]

var sampleData = [
  {
    date: '20190601',
    zipcode: '95054',
    temperature: 80
  },
  {
    date: '20190602',
    zipcode: '95054',
    temperature: 82
  },
  {
    date: '20190603',
    zipcode: '95054',
    temperature: 82
  },
  {
    date: '20190604',
    zipcode: '95054',
    temperature: 85
  },
  {
    date: '20190605',
    zipcode: '95054',
    temperature: 84
  },
  {
    date: '20190606',
    zipcode: '95054',
    temperature: 83
  },
  {
    date: '20190607',
    zipcode: '95054',
    temperature: 81
  }
];

firebase.js

firestore-cache/src/firebase.js

Auf GitHub ansehen

// [start firebase_access_implementation]

var FIREBASE_REALTIME_DB_BASE_URL = '.firebaseio.com';
var FIREBASE_REALTIME_DB_COLLECTION = '/cache';

/**
 * Returns the URL for a file in a firebase database.
 *
 * @param {string} fileName The filename in the database
 * @returns {string} The url for the file in the database
 */
function buildFirebaseUrl(fileName) {
  var serviceAccountCreds = getServiceAccountCreds();
  var projectId = serviceAccountCreds[BILLING_PROJECT_ID];

  if (fileName) {
    fileName = '/' + fileName;
  }
  var urlElements = [
    'https://',
    projectId,
    FIREBASE_REALTIME_DB_BASE_URL,
    FIREBASE_REALTIME_DB_COLLECTION,
    fileName,
    '.json'
  ];
  var url = urlElements.join('');
  return url;
}

/**
 * Generic method for handling the Firebase Realtime Database REST API.
 * For `get`: returns the data at the given url.
 * For `post`: posts the data in in firestore db at the given url and returns `undefined`.
 * For `delete`: deletes the data at the given url and returns `undefined`.
 *
 * @param {string} method Method for the REST API: `get`, `post`, or `delete`
 * @param {string} url REST endpoint
 * @param {string} [data] Data to be stored for `post` method
 * @returns {undefined|object} Returns data from the REST endpoint for `get`
 *          method. For other methods, returns `undefined`.
 */
function firebaseCache(method, url, data) {
  var oAuthToken = getOauthService().getAccessToken();

  var responseOptions = {
    headers: {
      Authorization: 'Bearer ' + oAuthToken
    },
    method: method,
    contentType: 'application/json'
  };

  // Add payload for post method
  if (method === 'post') {
    responseOptions['payload'] = JSON.stringify(data);
  }

  var response = UrlFetchApp.fetch(url, responseOptions);

  // Return value only for `get`.
  if (method === 'get') {
    var responseObject = JSON.parse(response);
    if (responseObject === null) {
      return null;
    } else {
      var autoKey = Object.keys(responseObject)[0];
      var returnValue = responseObject[autoKey];
    }
    return returnValue;
  }
}

function getFromCache(url) {
  return firebaseCache('get', url);
}

function deleteFromCache(url) {
  return firebaseCache('delete', url);
}

function putInCache(url, data) {
  return firebaseCache('put', url, data);
}

// [end firebase_access_implementation]

var SERVICE_ACCOUNT_CREDS = 'SERVICE_ACCOUNT_CREDS';
var SERVICE_ACCOUNT_KEY = 'private_key';
var SERVICE_ACCOUNT_EMAIL = 'client_email';
var BILLING_PROJECT_ID = 'project_id';

var scriptProperties = PropertiesService.getScriptProperties();

/**
 * Copy the entire credentials JSON file from creating a service account in GCP.
 * Service account should have `Firebase Admin` IAM role.
 */
function getServiceAccountCreds() {
  return JSON.parse(scriptProperties.getProperty(SERVICE_ACCOUNT_CREDS));
}

function getOauthService() {
  var serviceAccountCreds = getServiceAccountCreds();
  var serviceAccountKey = serviceAccountCreds[SERVICE_ACCOUNT_KEY];
  var serviceAccountEmail = serviceAccountCreds[SERVICE_ACCOUNT_EMAIL];

  return OAuth2.createService('FirebaseCache')
    .setAuthorizationBaseUrl('https://accounts.google.com/o/oauth2/auth')
    .setTokenUrl('https://accounts.google.com/o/oauth2/token')
    .setPrivateKey(serviceAccountKey)
    .setIssuer(serviceAccountEmail)
    .setPropertyStore(scriptProperties)
    .setCache(CacheService.getScriptCache())
    .setScope([
      'https://www.googleapis.com/auth/userinfo.email',
      'https://www.googleapis.com/auth/firebase.database'
    ]);
}

Zusätzliche Ressourcen

Der Chrome UX Connector ermöglicht es Tausenden von Nutzern, ein Dashboard zu verwenden, das auf einer etwa 20 GB großen BigQuery Tabelle basiert. Dieser Connector verwendet die Firebase Realtime Database zusammen mit dem Apps Script Cache Service für einen zweistufigen Caching-Ansatz. Details zur Implementierung finden Sie im Code.

Mit Firebase im Cache speichern Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Voraussetzungen

Beschränkungen

Lösung

Dienstkonto implementieren

Code zum Lesen und Schreiben in Firebase implementieren

getData() implementieren

Beispielcode

Hier sehen Sie ein vollständiges Beispiel für einen Connector, der Firebase für das Caching verwendet:

Zusätzliche Ressourcen

Mit Firebase im Cache speichern