Pamięć podręczna Firebase

Looker Studio ma własny system pamięci podręcznej raportów. Podczas tworzenia możesz zaimplementować niestandardową pamięć podręczną, aby szybciej generować raporty uniknąć ograniczeń RRSO.

Tworzysz na przykład oprogramowanie sprzęgające, które udostępnia historyczne dane pogodowe. z ostatnich 7 dni dla konkretnego kodu pocztowego. Oprogramowanie sprzęgające staje się coraz bardziej popularny, ale zewnętrzny interfejs API, z którego pobierasz dane, ma rygorystyczną szybkość i ograniczeniach. Interfejs API aktualizuje swoje dane tylko codziennie, więc dla określonego kodu pocztowego nie ma potrzeby pobierania tych samych danych wiele razy w ciągu jednego dnia. Użycie tego przewodnika po rozwiązaniu, możesz wdrożyć codzienną pamięć podręczną dla każdego kodu pocztowego.

Wymagania

  • Bazę danych czasu rzeczywistego Firebase – Jeśli nie masz do niego dostępu, utwórz projektu Google Cloud Platform (GCP) Przewodnik dla początkujących dotyczący tworzenia własnej platformy Firebase Instancja bazy danych czasu rzeczywistego.
  • Konto usługi GCP do odczytywania i zapisywania danych w czasie rzeczywistym w Firebase Baza danych.
  • społecznościowe oprogramowanie sprzęgające, które pobiera dane ze źródła;

Ograniczenia

  • Tego rozwiązania nie można używać z usługami zaawansowanymi Looker Studio. Kiedy używasz usług zaawansowanych Looker Studio, czyli kodu oprogramowania sprzęgającego w Google Apps, Skrypt nie ma dostępu do danych. Nie można więc przechowywać w pamięci podręcznej danych. za pomocą Apps Script.
  • Edytorzy i przeglądający raporty nie mogą zresetować tej konkretnej pamięci podręcznej.

Rozwiązanie

Wdrażanie konta usługi

  1. Utwórz konto usługi w projekcie Google Cloud.
  2. Sprawdź, czy to konto usługi ma dostęp do BigQuery w projekcie w chmurze.
    • Wymagane role zarządzania tożsamościami i dostępem: Firebase Admin
  3. Pobierz plik JSON, aby uzyskać klucze kont usługi. Zapisz w we właściwościach skryptu projektu oprogramowania sprzęgającego. Po dodaniu klucz, powinien wyglądać podobnie do tego w interfejsie Apps Script:
    Zapisywanie kluczy konta usługi we właściwościach skryptu
  4. Dodaj bibliotekę OAuth2 for Apps Script do projektu Apps Script.
  5. Zaimplementuj wymagany kod OAuth2 na koncie usługi:
firestore-cache/src/firebase.js
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'
    ]);
}

Implementacja kodu do odczytu i zapisu z Firebase

Do odczytu i zapisu w Firebase będziesz używać interfejsu API typu REST Firebase Database. Baza danych czasu rzeczywistego. Ten kod implementuje metody wymagane do dostępu do tego interfejsu API.

Implementacja getData()

Struktura istniejącego kodu w usłudze getData() bez buforowania powinna wyglądać podobny do tego:

firestore-cache/src/without-caching.js
/*
 * 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
  };
}

Aby użyć buforowania w kodzie getData(), wykonaj te czynności:

  1. Określ „fragment” lub „jednostka” danych, które powinny być buforowane.

  2. Utwórz unikalny klucz do przechowywania minimalnej jednostki danych w pamięci podręcznej.
    W przykładowej implementacji użyto pola zipcode z configparams jako klucz.
    Opcjonalnie: w przypadku pamięci podręcznej poszczególnych użytkowników utwórz klucz złożony, używając klucza podstawowego i tożsamość użytkownika. Przykładowa implementacja:
    js var baseKey = getBaseKey(request); var userEmail = Session.getEffectiveUser().getEmail(); var hasheduserEmail = getHashedValue(userEmail); var compositeKey = baseKey + hasheduserEmail;

  3. Jeśli dane w pamięci podręcznej istnieją, sprawdź, czy pamięć podręczna jest aktualne.
    W tym przykładzie dane dla konkretnego kodu pocztowego w pamięci podręcznej są zapisywane wraz z atrybutem bieżącej daty. Podczas pobierania danych z pamięci podręcznej data przechowywania w pamięci podręcznej to jest sprawdzany w porównaniu z bieżącą datą.

    var cacheForZipcode = {
      data    : <data being cached>,
      ymd    : <current date in YYYYMMDD format>
    }

  4. Jeśli dane w pamięci podręcznej nie istnieją lub są one nieaktualne, pobierz dane ze źródła i przechowywać ją w pamięci podręcznej.

W poniższym przykładzie reguła main.js zawiera kod getData() z buforowaniem .

Przykładowy kod

main.js

firestore-cache/src/main.js
// [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
// [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'
    ]);
}

Dodatkowe materiały

Oprogramowanie sprzęgające Chrome UX umożliwia korzystanie z panelu opartego na BigQuery o wielkości około 20 GB dla tysięcy użytkowników. To oprogramowanie sprzęgające korzysta z Bazy danych czasu rzeczywistego Firebase wraz z Apps Script Cache Service, która zapewnia dwuwarstwowe podejście do buforowania. Zobacz kod, by poznać szczegóły implementacji.