How to write scalable code in Meteor

Question

I found several articles about the Meteor method and its scaling capabilities, but does not fully explain how to do this. Most of them promote Oplog Tailing, but that’s not what I, as a programmer, have to think about when I write my code, right?

When I look at modul.io the prices are modal , they offer me changes the number of servos that my application will use, and claim that "each servo starts one instance of your application." Running multiple instances is a way to scale a Meteor application, right?

But what problems are associated with this? Possible race conditions with the database, right? How can I handle them? Do I need to design my application, so the race condition never arises or can I deal with them when they happen?

Before thinking about scaling, I used setInterval to run background tasks (for example, to send me an email every hour with some data). However, I do not want every instance of my application to do this, but only one. What is the solution for this? Is this possible with Meteor?

Answer 1

To have a scalable Meteor app, you need to consider a few things. Here are just design considerations, to a lesser extent, proxy methods or load balancing methods.

1) Avoid writing or reading from the file system. Meteor’s decision to create Assets.getText / getBinary only for the files included in the package, but without an intuitive way to read or write files for this reason. If you have several speakers, you can get a request that can only have data on one server, but not on another. Use S3 or GridFS to store any downloaded files from your drones.

2) If you have Meteor.setInterval in your code, it will run in concurrency with other "unmanned aerial vehicles", so make sure that you instead program it to work independently with the application itself through the cron task or creation, make sure that only one beep of your application does this.

3) If you have myCollection.find().observe.. anywhere in your server-side code that is not associated with a client instance, avoid it. This can create race conditions, since they will all receive information at the same time. Consider creating a separate application or make sure that only one beep can start them or they will run several times.

4) Avoid using variables that store user state. For example, you have a global variable of the type UsersOnline = [] , which you modify using the Meteor method or the publish method. Consider saving states on a mango or on redis so that each drone can access other states.

5) Make sure that each of the drones uses oplog instead of a polling interval system. Otherwise, if you change another beep again, there will be a delay in the other beep of your application.

Be careful with the requests you use to provide support for the oplog shank. Not all query types are supported, especially when observers are involved. You can use the facts package to determine this.

6) Consider using only your drones to connect to the websocket / ddp server. This is using WebAppInternals.setBundledJsCssPrefix('https://xxx.cloudfront.net'); (if you use cloudfront, any other cdn works fine) as a CDN in front of your application. This ensures that your application loads quickly, but each drone does not serve static assets again and again. It also reduces each of its loads.

7) Be careful with any packages you add and make sure that they also follow the above.

Workstations / Observers cron

You can either use a separate Meteor application, or make sure that one instance of your Meteor application does this. If you have access to an api that can determine which drones are on the network, you can do the task with the lowest port. Be careful that you do not do the task on the permanent port, as this single beep can be disabled, like considering redundancy.