I am trying to implement a project on the cloud for as minimum resources as possible (cpu, ram usage) and be able to handle medium to large number of requests through the database.
For the database part, I have chosen mongodb but for the backend I am between golang or quarkus.
Golang has many advantages but the only thing that concerns me is the interaction with mongodb. Mongodb official driver for Golang doesn't support reactive interface and despite the fact that golang can be easily implemented to be async I am afraid that mongodb will be my bottleneck.
Quarkus looks very promising, it is supported by Red Hat and it has been built to address many issues for the cloud era. It has been built on top of async servers and supports reactive communication with mongodb.
What is your opinion of the above? What would you suggest?
Thanks,
I'm doing these tests. Reactive quarkus and golang. So far go is much better
Related
I interested the Helidon SE with MongoDB and my POC requires some REST API with sort support.
I investigated some examples and implementation of helidon-dbclient-mongodb, but I didn't see the sort support.
Will this be implemented in the future or is there a reason why not?
The DbClient in Helidon SE is for abstracting basic operations (CRUD) to enable quick switch of underlying database.
If you need to use something that is part of the Mongo API and cannot be done using the configured queries, you would need to switch to the Mongo DB reactive client directly (instead of using the Helidon DbClient layer).
If I want to develop a Create, Read, Update, Delete (CRUD) system, what should I consider when choosing an API?
What are the pros and cons of NodeJS API and Java API?
Why NodeJS's single thread can make servers more scalable than multi-thread?
What databases can be accessed using Java API's Java Database Connectivity?
What are the similarities between NodeJS API and Java API?
I think the best choose for API for your CRUD development is depends on what type of your application. if you want a fast and reliable app, you should choose node.js for your API. But if you can ignore that and want to more like advance feature, you can pick java for your API.
Pros in NodeJS compare to Java API are Asynchronous, Very fast, and highly scalable. Cons in NodeJS compare to Java API are not suitable for CPU-intensive task, hard to operate when using relational database, and doesn't provide scalability.
Because single threaded have advantage such as can handle many client with ease, eliminate the need of more thread because of the event loop, and use the least threads to reduce memory and resource usage.
Oracle and MySQL.
About similarities we think Java API can do what NodeJS do but NodeJS can do all what Java API can do.
The answers to Does Sails.js or Meteor.js work with ArangoDB or OrientDB? do not contain info specifically about Meteor/Arangodb combination.
This is what I need to know: how close is ArangoDB to state of being a drop-in replacement for Mongo in Meteor?
The reasons I would prefer to use Arango:
friendlier license (Apache vs Mongo's AGPL)
graph db features built-in (I'm going to need that)
ACID transactions
Out of the box, Meteor only supports MongoDB directly, so there is no real "drop-in" alternative to MongoDB if you are a bleeding heart Meteor developer.
Because the Meteor server is built on top of Node.js you can simply use the JavaScript driver for ArangoDB to talk to ArangoDB from your server-side Meteor code. Alternatively you can simply use the ArangoDB HTTP API directly.
For a less database-specific solution you can look into Apollo as BennyB pointed out, but keep in mind that Apollo communicates using GraphQL, which while offering a lot of flexibility to frontend development also creates certain limitations for backend development, especially when it comes to optimizing queries for performance. A naive implementation of a GraphQL schema treats the database purely as a key-value storage, which will not play into the strengths you're interested in (specifically transactions won't be available this way).
I'm searching a simple implementation to push changes from a free relational database (PostgreSQL, MySQL, SQLite, etc.) to clients' browsers via WebSocket or WebPush.
I want to avoid all the server-side JavaScript ecosystem (Node.js, npm & cie) and the NoSQL databases.
All must be hosted in the servers of my company, I can't use third-party services.
I found these interesting solutions :
http://initd.org/psycopg/articles/2010/12/01/postgresql-notifications-psycopg2-eventlet/ [with Python]
https://gist.github.com/drocco007/6e44ac1a581546c16e67 [the same one slightly improved]
https://coussej.github.io/2015/09/15/Listening-to-generic-JSON-notifications-from-PostgreSQL-in-Go/ [with Go]
Do you know other ways to get this done?
Is PostgreSQL the more suitable free RDBMS to do this?
Can it be accomplished with a SQLite database?
Can Apache or NGinx abilities be used to achieve this?
Update 01/23/17: I wrote an application called postgresql2websocket in order to send PostgreSQL notifications over websockets using Python 3 with asyncio + aiohttp + asyncpg https://github.com/frafra/postgresql2websocket; you could combine it with PostgREST in order to have both standard REST APIs and realtime updates using WebSockets.
As far I know, there is no HTTP server extension for using SQL databases with Websockets without anything in the middle.
You can use Python on the server side, like this: Real Time Web Apps with (just) Python and Postgres. I think it could be improved thanks to aiopg. If you don't need Websockets, you can just use ngx_postgres.
If you like Django, Django Channels will be probably included in Django 1.10 (Redis/in-memory/... layer for channels and SQL backend).
You could use SQLite, but bear in mind that you have to implement a separate server side publish/subscribe mechanism (like Django channel does), because SQLite doesn't have one.
If you're just interested in pub/sub over Websockets, you could use Webdis (Redis-based solution): it would be probably lighter than a full SQL database.
Looking at the MongoDB project, it seems to have many drivers. It has a C Driver, Java Driver, Ruby Driver, etc...
How are these different from client libraries? It seems that each of those provide an interface to use the product (in this case MongoDB) from one of those languages.
Is there a technical difference between the two terms?
Thanks!
An application communicates with MongoDB by way of a client library, called a driver, that handles all interaction with the database in a language appropriate to the application.
Source: https://docs.mongodb.org/manual/applications/drivers/