Utilizzo di Cloud Firestore in modalità Datastore

Firestore è un database di documenti NoSQL creato per offrire scalabilità automatica, prestazioni elevate e facilità dello sviluppo di applicazioni. Si tratta della versione più recente di Datastore e introduce diversi miglioramenti rispetto a Datastore.

Poiché Firestore in modalità Datastore è ottimizzato per casi d'uso del server e per App Engine, consigliamo di utilizzare Firestore in modalità Datastore per database che verranno utilizzati principalmente dalle app di App Engine. Firestore in modalità nativa è più utile per i casi d'uso delle notifiche su dispositivi mobili e in tempo reale. Per ulteriori informazioni sulle modalità Firestore, consulta la pagina relativa alla scelta tra la modalità nativa e la modalità Datastore.

Questo documento descrive come utilizzare la libreria client di Google Cloud per archiviare e recuperare i dati in un database in modalità Datastore.

Prerequisiti e configurazione

Segui le istruzioni in Hello, World!" per Node.js su App Engineper configurare il tuo ambiente e il tuo progetto e per capire come sono strutturate le app Node.js in App Engine. Annota e salva l'ID progetto, perché ti servirà per eseguire l'applicazione di esempio descritta in questo documento.

Clonare il repository

Scarica (clona) il campione:

git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples
cd nodejs-docs-samples/appengine/datastore

Modifica la configurazione del progetto e imposta le dipendenze

In package.json, imposta @google-cloud/datastore come dipendenza, che fornisce le funzioni per utilizzare la modalità Datastore.

appengine/datastore/package.json 
{
  "name": "appengine-datastore",
  "description": "Sample for Google Cloud Datastore on Google App Engine.",
  "version": "0.0.1",
  "private": true,
  "license": "Apache-2.0",
  "author": "Google Inc.",
  "repository": {
    "type": "git",
    "url": "https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git"
  },
  "engines": {
    "node": "14.x.x"
  },
  "scripts": {
    "start": "node app.js",
    "system-test": "mocha --exit test/*.test.js",
    "test": "npm run system-test"
  },
  "dependencies": {
    "@google-cloud/datastore": "^6.0.0",
    "express": "^4.16.4"
  },
  "devDependencies": {
    "mocha": "^9.0.0",
    "supertest": "^6.0.0"
  }
}

Codice dell'applicazione

L'applicazione di esempio registra, recupera e visualizza gli indirizzi IP dei visitatori. Puoi notare che una voce di log è una semplice classe a due campi che riceve il tipo visit, e viene salvata in modalità Datastore utilizzando il comando save del set di dati. Successivamente, le dieci visite più recenti vengono recuperate in ordine decrescente in base al comando runQuery del set di dati.

appengine/datastore/app.js 
'use strict';

const express = require('express');
const crypto = require('crypto');

const app = express();
app.enable('trust proxy');

// By default, the client will authenticate using the service account file
// specified by the GOOGLE_APPLICATION_CREDENTIALS environment variable and use
// the project specified by the GOOGLE_CLOUD_PROJECT environment variable. See
// https://github.com/GoogleCloudPlatform/google-cloud-node/blob/master/docs/authentication.md
// These environment variables are set automatically on Google App Engine
const {Datastore} = require('@google-cloud/datastore');

// Instantiate a datastore client
const datastore = new Datastore({
  projectId: 'long-door-651',
});

/**
 * Insert a visit record into the database.
 *
 * @param {object} visit The visit record to insert.
 */
const insertVisit = visit => {
  return datastore.save({
    key: datastore.key('visit'),
    data: visit,
  });
};

/**
 * Retrieve the latest 10 visit records from the database.
 */
const getVisits = () => {
  const query = datastore
    .createQuery('visit')
    .order('timestamp', {descending: true})
    .limit(10);

  return datastore.runQuery(query);
};

app.get('/', async (req, res, next) => {
  // Create a visit record to be stored in the database
  const visit = {
    timestamp: new Date(),
    // Store a hash of the visitor's ip address
    userIp: crypto
      .createHash('sha256')
      .update(req.ip)
      .digest('hex')
      .substr(0, 7),
  };

  try {
    await insertVisit(visit);
    const [entities] = await getVisits();
    const visits = entities.map(
      entity => `Time: ${entity.timestamp}, AddrHash: ${entity.userIp}`
    );
    res
      .status(200)
      .set('Content-Type', 'text/plain')
      .send(`Last 10 visits:\n${visits.join('\n')}`)
      .end();
  } catch (error) {
    next(error);
  }
});

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

index.yaml file in uso

L'app di esempio esegue semplici query. Le query più elaborate in modalità Datastore richiedono uno o più indici, che devono essere specificati in un file index.yaml che si carica insieme all'app. Questo file può essere creato manualmente o generato automaticamente durante il test dell'app in locale.

Test locale

Se devi sviluppare e testare la tua applicazione in locale, puoi utilizzare l'emulatore di modalità Datastore.

Per ulteriori informazioni

Per informazioni complete sulla modalità Datastore, tra cui ottimizzazioni e concetti, consulta la documentazione di Cloud Firestore in modalità Datastore.