初心者でもできる、Google Cloud Firestore DatastoreモードとPython or Node.jsで始めるRESTful APIサービス構築方法

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

"use strict";


const express = require('express');
const app = express();
const message = require('./message');
app.use(express.json());


app.get('/', (req, res) => {
    res.end('Welcome to Datastore RESTful API demo!');
});


app.get('/api/msg', async (req, res) => {
    var results = await message.listMessages();
    res.json(results).end();
});


app.get('/api/msg/:group/:id', async (req, res) => {
    var group = parseInt(req.params.group);
    var id = parseInt(req.params.id);
    var results = await message.getMessageById(group, id);
    res.json(results).end();
});


app.post('/api/msg/:group', async (req, res) => {
    var group = parseInt(req.params.group);
    var sender = req.body.sender;
    var msg = req.body.message;


    var results = await message.saveMessage(group, sender, msg);
    res.json(results).end();
});


app.delete('/api/msg/:group/:id', async (req, res) => {
    var group = parseInt(req.params.group);
    var id = parseInt(req.params.id);
    var results = await message.deleteMessage(group, id);
    res.json(results).end();
});


const port = process.env.PORT || 5000;
app.listen(port, () => console.log(`Listening on port ${port}`));

"use strict";


const { Datastore } = require('@google-cloud/datastore');


// Instantiate a datastore client
const datastore = new Datastore({
    projectId: 'xxxxxxxx',
});


/**
 * List all the messages in the database
 */
async function listMessages() {
    var query = datastore.createQuery('Message').order('timestamp', { descending: true }).limit(10);
    var results = await datastore.runQuery(query);
    return { "Status": "Success", "results": "Get target messages successfully.", "data": results };
}


/**
 * Get target message with specific message id
 */
async function getMessageById(group, id) {
    // var query = datastore.createQuery('Message').filter('id', '=', id);
    // var results = await datastore.runQuery(query);
    var message = datastore.key(['ChatGroup', group, 'Message', id]);
    var results = await datastore.get(message);
    if (null == results[0]) {
        return { "Status": "Failed", "results": "No message under with the conditions.", "data": null };
    } else {
        return { "Status": "Success", "results": "Get target messages successfully.", "data": results[0] };
    }


}


/**
 * Save message with passed data
 */
async function saveMessage(group, sender, message) {
    // var groupKey = datastore.key(['ChatGroup', group]);
    var results = await datastore.save({
        key: datastore.key(['ChatGroup', group, 'Message']),
        data: {
            sender: sender,
            message: message,
            timestamp: new Date(),
        },
    });
    return { "Status": "Success", "results": "Save target message successfully.", "data": results };
}


/**
 * Delete target message with specific message id
 */
async function deleteMessage(group, id) {
    var message = datastore.key(['ChatGroup', group, 'Message', id]);
    var results = await datastore.delete(message);
    if (0 == results[0].indexUpdates) {
        return { "Status": "Failed", "results": "Target message does not exist.", indexUpdates: results[0].indexUpdates };
    } else {
        return { "Status": "Success", "results": "Delete target message successfully.", indexUpdates: results[0].indexUpdates };
    }
}


module.exports = { listMessages, getMessageById, saveMessage, deleteMessage }

……
    "scripts": {
        "start": "node server.js",
        "system-test": "mocha --exit test/*.test.js",
        "test": "npm run system-test"
    },
    "dependencies": {
        "@google-cloud/datastore": "^7.0.0",
        "express": "^4.16.4"
    },
……

.
├── node_modules
├── app.js
├── message.js
├── package.json
└── server.js

curl -X GET http://localhost:5000/

curl -H "Content-Type: application/json" -X POST -d "{\"sender\":\"bob\",\"message\":\"Testing message from Node.js .\"}" http://localhost:5000/api/msg/5634161670881280

curl -X GET http://localhost:5000/api/msg/5634161670881280/5714489739575296

curl -X GET http://localhost:5000/api/msg

curl -X DELETE http://localhost:5000/api/msg/5634161670881280/5714489739575296
curl -X GET http://localhost:5000/api/msg/5634161670881280/5714489739575296

py -m venv .venv
.venv\scripts\activate

pip install google-cloud-datastore flask-restful
pip freeze > requirements.txt

from flask import Flask, jsonify
from flask_restful import Api, Resource, reqparse
from datastore import DatastoreManager
 
 
class Message(Resource):
    def __init__(self):
        self.manager = DatastoreManager()
        super().__init__()


    def get(self, group, id):
        return jsonify(self.manager.read_message_by_id(int(group), int(id)))
 
    def delete(self, group, id):
        return jsonify(self.manager.delete_message_by_id(int(group), int(id)))
 
class Messages(Resource):
    def __init__(self):
        self.manager = DatastoreManager()
        super().__init__()


    def get(self, group):
        return jsonify(self.manager.read_all_messages(int(group)))
   
    def post(self, group):
        args = reqparse.RequestParser() \
            .add_argument('sender', type=str, location='json', required=True, help="Empty sender") \
            .add_argument('message', type=str, location='json', required=True, help="Empty message") \
            .parse_args()
 
        return jsonify(self.manager.save_message(int(group), args['sender'], args['message']))
 
app = Flask(__name__)
api = Api(app, default_mediatype="application/json")
api.add_resource(Message, '/api/msg/<group>/<id>')
api.add_resource(Messages, '/api/msg/<group>')
app.run(host='0.0.0.0', port=5001, use_reloader=True)

from google.cloud import datastore
import datetime




class DatastoreManager:


    def __init__(self):
        self.ds = datastore.Client(project='xxxxxxxx')


    def save_message(self, group, sender, message):
        entity = datastore.Entity(key=self.ds.key('ChatGroup', group, 'Message'))
        entity.update({
            'sender': sender,
            'message': message,
            'timestamp': datetime.datetime.now(tz=datetime.timezone.utc)
        })


        result = self.ds.put(entity)
        return {"status": "Success", "results": "Save the target message successfully.", "data": result}


    def read_all_messages(self, group):
        groupKey = self.ds.key('ChatGroup', group)
        msgQuery = self.ds.query(kind='Message', ancestor=groupKey, order=('-timestamp',))
        result = list(msgQuery.fetch(limit=10))
        return {"status": "Success", "results": "Get the top 10 messages successfully.", "data": result}


    def read_message_by_id(self, group, id):
        msgKey = self.ds.key('ChatGroup', group, 'Message', id)
        result = self.ds.get(msgKey)
        if None == result:
            return {"status": "Failed", "errMessage": "No target data row."}
        else:
            return {"status": "Success", "results": "Get the target message successfully.", "data": result}


    def delete_message_by_id(self, group, id):
        msgKey = self.ds.key('ChatGroup', group, 'Message', id)
        result = self.ds.delete(msgKey)
        return {"status": "Success", "results": "Delete the target message successfully."}

.
├── .venv
├── datastore.py
├── requirements.txt
└── server.py

curl -H "Content-Type: application/json" -X POST -d "{\"sender\":\"bob\",\"message\":\"Testing message from Python.\"}" http://localhost:5001/api/msg/5634161670881280

curl -X GET http://localhost:5001/api/msg/5634161670881280/5635008819625984

curl -X GET http://localhost:5001/api/msg/5634161670881280/563500881962598411

curl -X GET http://localhost:5001/api/msg/5634161670881280

curl -X DELETE http://localhost:5001/api/msg/5634161670881280/5665673409724416
curl -X GET http://localhost:5001/api/msg/5634161670881280/5665673409724416

/**
     * Helper to create a Key object, scoped to the instance's namespace by
     * default.
     *
     * You may also specify a configuration object to define a namespace and path.
     *
     * @param {object|string|array} [options] Key path. To specify or override a namespace,
     *     you must use an object here to explicitly state it.
     * @param {string|array} [options.path]  Key path.
     * @param {string} [options.namespace] Optional namespace.
     * @returns {Key} A newly created Key from the options given.
     *
     * @example
     * ```
     * <caption>Create an incomplete key with a kind value of `Company`.
     * Since no Id is supplied, Datastore will generate one on save.</caption>
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const key = datastore.key('Company');
     *
     * ```
     * @example
     * ```
     * <caption>Create a complete key with a kind value of `Company` and Id `123`.</caption>
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const key = datastore.key(['Company', 123]);
     *
     * ```
     * @example
     * ```
     * <caption>If the ID integer is outside the bounds of a JavaScript Number
     * object, create an Int.</caption>
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const key = datastore.key([
     *   'Company',
     *   datastore.int('100000000000001234')
     * ]);
     *
     * ```
     * @example
     * ```
     * <caption>Create a complete key with a kind value of `Company` and name `Google`.
     * Because the supplied Id is a string, Datastore will prefix it with "name=".
     * Had the supplied Id been numeric, Datastore would prefix it with the standard, "id=".</caption>
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const key = datastore.key(['Company', 'Google']);
     *
     * ```
     * @example
     * ```
     * <caption>Create a complete key from a provided namespace and path.</caption>
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const key = datastore.key({
     *   namespace: 'My-NS',
     *   path: ['Company', 123]
     * });
     *
     * ```
     * @example
     * ```
     * <caption>Create a complete key that specifies an ancestor. This will create a Team entity
     * with a name of "Datastore", which belongs to the Company with the "name=Google" key.</caption>
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const key = datastore.key(['Company', 'Google', 'Team', 'Datastore']);
     *
     * ```
     * @example
     * ```
     * <caption>Create a incomplete key that specifies an ancestor. This will create an Employee entity
     * with an auto-generated Id, which belongs to the Company with the "name=Google" key.</caption>
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const key = datastore.key(['Company', 'Google', 'Employee']);
     * ```
     */

from google.cloud import datastore


# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()


# Query filters are omitted in this example as any ancestor queries with a
# non-key filter require a composite index.
ancestor = client.key("TaskList", "default")
query = client.query(kind="Task", ancestor=ancestor)

google.api_core.exceptions.FailedPrecondition: 400 no matching index found. recommended index is:
- kind: Message
  ancestor: yes
  properties:
  - name: timestamp
    direction: desc

indexes:

- kind: Message
  ancestor: yes
  properties:
  - name: timestamp
    direction: desc

google.api_core.exceptions.FailedPrecondition: 400 The index for this query is not ready to serve. See the Datastore Indexes page in the Admin Console.