Utilizzo di Cloud Firestore in modalità Datastore

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

Dato che Firestore in modalità Datastore è ottimizzata per i casi d'uso dei server e per App Engine, ti consigliamo di utilizzare Firestore in modalità Datastore per i database che verranno utilizzati principalmente dalle app App Engine. Firestore in modalità Native è più utile per i casi d'uso delle notifiche su dispositivi mobili e in tempo reale. Per ulteriori informazioni sulle modalità Firestore, consulta Scegliere tra la modalità Native 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 Engine per 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 del progetto, perché ti servirà per eseguire l'applicazione di esempio descritta in questo documento.

Clona il repository

Scarica (clona) l'esempio:

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 usare 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": "16.x.x"
  },
  "scripts": {
    "start": "node app.js",
    "system-test": "mocha --exit test/*.test.js",
    "test": "npm run system-test"
  },
  "dependencies": {
    "@google-cloud/datastore": "^7.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 mostra gli IP dei visitatori. Come puoi notare, una voce di log è una semplice classe a due campi di tipo visit, salvata in modalità Datastore con il comando save del set di dati. Quindi, le dieci visite più recenti vengono recuperate in ordine decrescente, utilizzando il 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.');
});

Utilizzo di index.yaml file in corso...

L'app di esempio esegue query semplici. Le query in modalità Datastore più elaborate richiedono uno o più indici, che devi specificare in un file index.yaml che carichi insieme all'app. Questo file può essere creato manualmente o generato automaticamente durante il test dell'app a livello 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, inclusi ottimizzazioni e concetti, consulta la documentazione di Firestore in modalità Datastore.