初心者でもできる、Alibaba Cloud TablestoreとPython or Node.jsで始めるRESTful APIサービス構築方法

{
    "PK": {
        "Values": [
            2,
            "cli"
        ]
    },
    "Attr": {
        "Values": [
            {
                "c": "date",
                "v": "20220825"
            },
            {
                "c": "os",
                "v": "Windows10"
            }
        ]
    }
}

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

"use strict";


const TableStore = require('tablestore');
var Long = TableStore.Long;
let client;
let tableName = process.env.tableName;


/**
 * Generate and return TableStore client with specific configuration
 * @returns TableStore client
 */
function getClient() {
    if (!client) {
        client = new TableStore.Client({
            accessKeyId: process.env.accessKeyId,
            secretAccessKey: process.env.secretAccessKey,
            endpoint: process.env.endpoint,
            instancename: process.env.instancename
        });
    }
    return client;
}


/**
 * Scan the TableStore data based on default range
 * @returns
 */
async function getRange() {
    client = getClient();
    var params = {
        tableName: tableName,
        direction: TableStore.Direction.FORWARD,
        inclusiveStartPrimaryKey: [{ "id": TableStore.INF_MIN }, { "group": TableStore.INF_MIN }],
        exclusiveEndPrimaryKey: [{ "id": TableStore.INF_MAX }, { "group": TableStore.INF_MAX }],
        limit: 10
    };
    return new Promise((resolve, reject) => {
        client.getRange(params, function (err, data) {
            if (err) {
                console.log('error:', err);
                return;
            }
            resolve(data);
        });
    });
}


/**
 * Scan the TableStore data based on default range
 * @param {*} id
 * @param {*} group
 * @param {*} sender
 */
async function getRow(id, group, sender = null) {
    client = getClient();
    var params = {
        tableName: tableName,
        primaryKey: [{ 'id': Long.fromNumber(id) }, { 'group': group }],
    };
    if (null != sender) {
        // Support CompositeCondition
        // var condition = new TableStore.CompositeCondition(TableStore.LogicalOperator.AND);
        // condition.addSubCondition(new TableStore.SingleColumnCondition('sender', sender, TableStore.ComparatorType.EQUAL));
        // condition.addSubCondition(new TableStore.SingleColumnCondition('sender', sender, TableStore.ComparatorType.EQUAL));
        var condition = new TableStore.SingleColumnCondition('sender', sender, TableStore.ComparatorType.EQUAL);
        params.columnFilter = condition;
    }
    return new Promise((resolve, reject) => {
        client.getRow(params, function (err, data) {
            if (err) {
                console.log('error:', err);
                if (err.code == 400) {
                    resolve({ "row": [] });
                }
                return;
            }
            resolve(data);
        });
    });
}


/**
 * Put row in the target TableStore table
 * @param {*} id
 * @param {*} group
 * @param {*} sender
 * @param {*} message
 */
async function putRow(id, group, sender, message) {
    client = getClient();
    var params = {
        tableName: tableName,
        condition: new TableStore.Condition(TableStore.RowExistenceExpectation.IGNORE, null),
        primaryKey: [{ 'id': Long.fromNumber(id) }, { 'group': group }],
        attributeColumns: [
            { 'sender': sender },
            { 'message': message }
        ],
        returnContent: { returnType: TableStore.ReturnType.Primarykey }
    };
    return new Promise((resolve, reject) => {
        client.putRow(params, function (err, data) {
            if (err) {
                console.log('error:', err);
                return;
            }
            resolve(data);
        });
    });
}


/**
 * Put row in the target TableStore table
 * @param {*} id
 * @param {*} group
 */
async function deleteRow(id, group) {
    client = getClient();
    var params = {
        tableName: tableName,
        condition: new TableStore.Condition(TableStore.RowExistenceExpectation.IGNORE, null),
        primaryKey: [{ 'id': Long.fromNumber(id) }, { 'group': group }],
    };
    return new Promise((resolve, reject) => {
        client.deleteRow(params, function (err, data) {
            if (err) {
                console.log('error:', err);
                return;
            }
            resolve(data);
        });
    });
}


module.exports = { putRow, getRange, getRow, deleteRow }

"use strict";


const ts = require('./ts');


async function listMessages() {
    var result = await ts.getRange();
    if (result.rows.length == 0) {
        return { "rows": 0, "results": "No data" };
    } else {
        return { "rows": result.rows.length, "results": "Get top 10 messages successfully.", "data": result.rows };
    }
}


async function getMessageByGroup(id, group) {
    var result = await ts.getRow(id, group);
    if (result.row.length == 0) {
        return { "rows": 0, "results": "No data" };
    } else {
        return { "rows": result.row.length, "results": "Get target message successfully.", "data": result.row };
    }
}


async function getMessageByGroupAndSender(id, group, sender) {
    var result = await ts.getRow(id, group, sender);
    if (result.row.length == 0) {
        return { "rows": 0, "results": "No data" };
    } else {
        return { "rows": result.row.length, "results": "Get target message successfully.", "data": result.row };
    }
}


async function saveMessage(id, group, sender, message) {
    var result = await ts.putRow(id, group, sender, message);
    if (result.consumed.capacityUnit.write == 0) {
        return { "rows": 0, "results": "Failed to save message." };
    } else {
        return { "rows": result.row.length, "results": "Save target message successfully.", "data": result.row };
    }
}


async function deleteMessage(id, group) {
    var result = await ts.deleteRow(id, group);
    return { "rows": 1, "results": "Delete target message successfully.", "data": result };
}


module.exports = { listMessages, getMessageByGroup, getMessageByGroupAndSender, saveMessage, deleteMessage }

"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 Tablestore RESTful API demo!');
});


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


app.get('/api/msg/:id/:group', async (req, res) => {
    var id = parseInt(req.params.id);
    var group = req.params.group;


    var results = await message.getMessageByGroup(id, group);
    res.json(results).end();
});


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


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


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


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


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

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

curl -H "Content-Type: application/json" -X POST -d "{\"id\":\"20220830101\",\"group\":\"restful\",\"sender\":\"bob\",\"message\":\"This is testing message.\"}" http://localhost:5000/api/msg

curl -X GET http://localhost:5000/api/msg
curl -X GET http://localhost:5000/api/msg/20220830101/restful
curl -X GET http://localhost:5000/api/msg/20220830101/restful/bob

curl -X GET http://localhost:5000/api/msg/20220830101/restful/bob121

curl -X DELETE http://localhost:5000/api/msg/20220830101/restful

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

.
├── .venv
├── server.py
└── ts.py

from tablestore import *
import os


class OTSManager:


    def __init__(self):
        self.endpoint = os.getenv('OTS_ENDPOINT')
        self.access_key = os.getenv('OTS_ID')
        self.access_secret = os.getenv('OTS_SECRET')
        self.instance = os.getenv('OTS_INSTANCE')
        self.table = os.getenv('OTS_TABLE')
        self.client = OTSClient(self.endpoint, self.access_key, self.access_secret, self.instance)
   
    def get_row(self, id, group, sender=None):
        try:
            primary_key = [('id',id), ('group',group)]
            columns_to_get = [] # 取得する列のリスト、あるいは行全体を取得したい場合は空のリストを指定します
            if sender:
                condition = SingleColumnCondition('sender', sender, ComparatorType.EQUAL)
            else:
                condition = None
            consumed, return_row, next_token = self.client.get_row(self.table, primary_key, columns_to_get, condition)
            if return_row:
                return {"status": "Success", "readCU": consumed.read, "data": {"primaryKey": return_row.primary_key, "attrColumn": return_row.attribute_columns}}
            else:
                return {"status": "Failed", "errMessage": "No target data row."}
        except OTSClientError as e:
            return {"status": "Failed", "HTTPStatus": e.get_http_status(), "errMessage": e.get_error_message()}
        except OTSServiceError as e:
            return {"status": "Failed", "HTTPStatus": e.get_http_status(), "errMessage": e.get_error_message(), "errCode": e.get_error_code()}
           
    def put_row(self, id, group, sender, message):
        try:
            primary_key = [('id',id), ('group',group)]
            attribute_columns = [('sender',sender), ('message',message)]
            row = Row(primary_key, attribute_columns)
            condition = Condition(RowExistenceExpectation.EXPECT_NOT_EXIST) # Expect not exist：この行が存在しない場合のみ、テーブルに入れる。
            consumed, return_row = self.client.put_row(self.table, row, condition)
            return {"status": "Success", "writeCU": consumed.write}
        except OTSClientError as e:
            return {"status": "Failed", "HTTPStatus": e.get_http_status(), "errMessage": e.get_error_message()}
        except OTSServiceError as e:
            return {"status": "Failed", "HTTPStatus": e.get_http_status(), "errMessage": e.get_error_message(), "errCode": e.get_error_code()}


    def delete_row(self, id, group):
        try:
            primary_key = [('id',id), ('group',group)]
            row = Row(primary_key)
            condition = Condition(RowExistenceExpectation.IGNORE)
            consumed, return_row = self.client.delete_row(self.table, row, condition)
            return {"status": "Success", "writeCU": consumed.write}
        except OTSClientError as e:
            return {"status": "Failed", "HTTPStatus": e.get_http_status(), "errMessage": e.get_error_message()}
        except OTSServiceError as e:
            return {"status": "Failed", "HTTPStatus": e.get_http_status(), "errMessage": e.get_error_message(), "errCode": e.get_error_code()}

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


    def get(self, id, group):
        return jsonify(self.manager.get_row(int(id), group))
 
    def post(self, id, 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.put_row(int(id), group, args['sender'], args['message']))
 
 
    def delete(self, id, group):
        return jsonify(self.manager.delete_row(int(id), group))
 
 
app = Flask(__name__)
api = Api(app, default_mediatype="application/json")
api.add_resource(Message, '/api/msg/<id>/<group>')
app.run(host='0.0.0.0', port=5001, use_reloader=True)

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

curl -X GET http://localhost:5001/api/msg/20220905001/python

curl -X DELETE http://localhost:5001/api/msg/20220905001/python

curl -X GET http://localhost:5001/api/msg/20220905001/python11

……
TypeError: Descriptors cannot not be created directly.
If this call came from a _pb2.py file, your generated code is out of date and must be regenerated with protoc >= 3.19.0.
If you cannot immediately regenerate your protos, some other possible workarounds are:
 1. Downgrade the protobuf package to 3.20.x or lower.
 2. Set PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=python (but this will use pure-Python parsing and will be much slower).

tablestore@SQL> show tables;
OTSInternalServerError Internal server error. 0005e70b-af4d-1323-8e6c-ca0b01cb1bee
tablestore@SQL>