Pamięć podręczna Firebase

Cel: zwiększenie wydajności panelu i uniknięcie limitów szybkości zewnętrznego interfejsu API przez wdrożenie niestandardowej pamięci podręcznej dla łącznika.

Looker Studio ma własny system pamięci podręcznej dla raportów. Podczas tworzenia konektora możesz wdrożyć niestandardową pamięć podręczną, aby przyspieszyć generowanie raportów i uniknąć limitów żądań interfejsu API.

Na przykład tworzysz łącznik, który udostępnia historyczne dane pogodowe z ostatnich 7 dni dla określonego kodu pocztowego. Twój łącznik staje się coraz bardziej popularny, ale zewnętrzny interfejs API, z którego pobierasz dane, ma ścisłe limity szybkości. Interfejs API aktualizuje dane tylko raz dziennie, więc w przypadku konkretnego kodu pocztowego nie ma potrzeby pobierania tych samych danych wielokrotnie w ciągu dnia. Korzystając z tego przewodnika, możesz wdrożyć codzienną pamięć podręczną dla każdego kodu pocztowego.

Wymagania

• Baza danych czasu rzeczywistego Firebase. Jeśli nie masz dostępu do takiego projektu, utwórz projekt Google Cloud Platform (GCP) i postępuj zgodnie z przewodnikiem Pierwsze kroki, aby utworzyć własną instancję bazy danych czasu rzeczywistego Firebase.
• Konto usługi GCP do odczytywania i zapisywania danych z Bazy danych czasu rzeczywistego Firebase.
• Oprogramowanie sprzęgające utworzone przez społeczność, które pobiera dane ze źródła.

Ograniczenia

• Tego rozwiązania nie można używać z usługami zaawansowanymi Looker Studio. Gdy korzystasz z usług zaawansowanych Looker Studio, kod oprogramowania sprzęgającego w Apps Script nie ma dostępu do danych. Dlatego nie możesz zapisywać danych w pamięci podręcznej za pomocą Apps Script.
• Osoby edytujące i wyświetlające 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. Upewnij się, że to konto usługi ma dostęp do BigQuery w projekcie w chmurze.
   • Wymagane role Identity and Access Management (IAM): Firebase Admin
3. Pobierz plik JSON, aby uzyskać klucze kont usługi. Przechowuj zawartość pliku we właściwościach skryptu projektu łącznika. Po dodaniu kluczy interfejs Apps Script powinien wyglądać podobnie do tego:
   
4. Dołącz bibliotekę OAuth2 for Apps Script do projektu Apps Script.
5. Wdróż wymagany kod OAuth2 na koncie usługi:

firestore-cache/src/firebase.js

Wyświetl w GitHubie

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'
    ]);
}

Wdróż kod do odczytywania i zapisywania danych w Firebase

Do odczytywania i zapisywania danych w bazie danych czasu rzeczywistego Firebase będziesz używać interfejsu Firebase Database REST API. Poniższy kod implementuje metody potrzebne do uzyskania dostępu do tego interfejsu API.

Implementacja funkcji getData()

Struktura dotychczasowego kodu getData() bez buforowania powinna wyglądać tak:

firestore-cache/src/without-caching.js

Wyświetl w GitHubie

/*
 * 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żywać pamięci podręcznej w kodzie getData(), wykonaj te czynności:

1. Określ „fragment” lub „jednostkę” danych, które mają być buforowane.

2. Utwórz unikalny klucz do przechowywania w pamięci podręcznej minimalnej jednostki danych.
   W przykładowej implementacji jako klucz używana jest wartość zipcode z configparams.
   Opcjonalnie: w przypadku pamięci podręcznej dla poszczególnych użytkowników utwórz klucz złożony z klucza podstawowego i tożsamości 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 są aktualne.
   W tym przykładzie dane w pamięci podręcznej dla określonego kodu pocztowego są zapisywane z bieżącą datą. Gdy dane są pobierane z pamięci podręcznej, data pamięci podręcznej jest sprawdzana pod kątem zgodności 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ą nieaktualne, pobierz dane ze źródła i zapisz je w pamięci podręcznej.

W tym przykładzie main.js zawiera kod getData() z zastosowanym buforowaniem.

Przykładowy kod

Oto pełny przykład oprogramowania sprzęgającego, które używa Firebase do buforowania:

main.js

firestore-cache/src/main.js

Wyświetl w GitHubie

// [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

Wyświetl w GitHubie

// [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

Chrome UX Connector udostępnia tysiącom użytkowników panel oparty na tabeli BigQuery o rozmiarze około 20 GB. To oprogramowanie sprzęgające korzysta z Bazy danych czasu rzeczywistego Firebase i usługi pamięci podręcznej Apps Script, co zapewnia dwuwarstwowe podejście do buforowania. Szczegółowe informacje o implementacji znajdziesz w sekcji kod.