I am looking for max allowed active connections to Firebase Realtime DB in Blaze Plan for below
How many active RtDB listeners (StreamSubscription) from single device
How many active RtDB listeners (StreamSubscription) to single db from all connected devices
In below link I see,
total Simultaneous connections allowed are 200,000
https://firebase.google.com/docs/database/usage/limits
(A simultaneous connection is equivalent to one mobile device, browser tab, or server app connected to the database.)
But I could not find StreamSubscription limit per device, and StreamSubscription limit per db.
Related
In Firebase Realtime Database I want to set limit for number of data read request per user or per IP.
Similar like Firebase Authentication Limits(e.g New account creation 100 accounts/IP address/hour)
Is there any way to achieve this in Firebase Realtime Database ?
The only way to implement this would be to force client apps through a backend API that you control. That API will have to record the amount of data read per IP, and reject requests that exceed your limits.
Otherwise, there is no way to impose limits as you describe. It's not a matter of simple configuration.
When using Cloud Firestore, it is possible to subscribe to the change/update events for the document of which mobile user is interested in.
What I wonder is: Is there a practical limit for the number of realtime data listeners for each mobile device? For an intermediate mobile device is there any limit we should not exceed?
IMHO, creating realtime data listeners on Firestore in practice corresponds to the topic subscriptions on a socket server which shouldn't have any overhead on the client-side. However, I couldn't find any documentation on this very specific issue of Firestore implementation and would like to ask for any theoretical or practical know-how you have.
In my project I‘m using the realtime database as well as the Firestore database. My cloud functions triggers when a document is added to a specific collection inside my Firestore database. The function then writes to my realtime database to update some statistics. I noticed that even if no user is connected to my realtime database, the count of concurrent connections increases when the cloud function writes to the realtime database. Does this mean that my cloud functions count as concurrent connections and will decrease the amount of users that can connect to my realtime database at once as there is a limit of 100k concurrent connections?
You'll incur one connection for each server instance running your functions. It is not one per individual function invocation. So, if it only requires one server instance to run your function, then it will only cost one connection. When a server instance is automatically deallocated from your project, its connection will go away.
You will need an extremely busy set of functions in order to make a real dent in your 100K concurrent connection cap for Realtime Database. I wouldn't worry about it.
My app run in background. If app run in background, is still simultaneous connected with realtimeDB? Or if this app doesn't use realtimeDB for a while, does not count simultaneous connected?
If it's count anyway, can I only get 100,000 user?
Your app is connected to the realtimeDB as long as your listener is active. If you want to stop listening you need to remove the listener according to your needs and to the activity cycle.
For Android you can use this code in your onDestroy() method.
databaseReference.removeEventListener(valueEventListener);
Hope it helps.
I am answering your three part question in order..,
Firebase database library manages the connection to your database in the backend and this starts right away at the start of the app and this starts counting against your simultaneous connections and when this limit reaches the Max Connections limit of 100k any new connections will be dropped until the existing connections drop by either closing the app or app goes offline after a specified time-out or forcefully closing the DB connections by calling
FirebaseDatabase.getInstance().goOffline()
You can however know the whether a given client is connected or not by using the listener at FirebaseDatabase.getInstance().getReference(".info/connected") this however works locally and doesn't explicitly connect to FirebaseDatabase cloud instance., more can be read here
Once you implement the above connection listener you will see that the SDK manages this dynamically in a way that the connections disconnect automatically if there are no listeners attached and if no DB operations like .setValue() are made in the app in last 60 seconds.., but the presence of ValueEventListners will override this and will ensure continuous connectivity with the DB. again this can be overridden and the connection can be severed by explicitly calling FirebaseDatabase.getInstance().goOffline()
Coming to the Max Limit of 100k simultaneous users; as can be seen in Firebase Plans
There is a limit of 100,000 simultaneous connections per database on
the Flame and Blaze plans. See Pricing FAQ for more information.
If you cross this and for scaling you need to increase the limit, you can explicitly ask Google Firebase Team for the support and they will handle this on a case by case basis to ensure your app can scale as required when required..
What is a "simultaneous database connection"?
A simultaneous connection is equivalent to one mobile device, browser
tab, or server app connected to the database. Firebase imposes hard
limits on the number of simultaneous connections to your app's
database. These limits are in place to protect both Firebase and our
users from abuse.
The Spark plan limit is 100 and cannot be raised. The Flame and Blaze
plans have a limit of 100,000 simultaneous connections per database.
If you need more than 100,000 simultaneous connections, contact
Firebase support.
This limit isn't the same as the total number of users of your app,
because your users don't all connect at once. We encourage you to
monitor your peak simultaneous database connections and upgrade or add
more databases if needed.
On Firebase pricing page it has been stated that:
What is a "simultaneous database connection"?
A simultaneous connection is equivalent to one mobile device, browser tab, or server app connected to the database. Firebase imposes hard limits on the number of simultaneous connections to your app's database. These limits are in place to protect both Firebase and our users from abuse.
The Spark plan limit is 100 and cannot be raised. The Flame and Blaze plans have a limit of 100,000 simultaneous connections per database. If you need more than 100,000 simultaneous connections, contact Firebase support.
This limit isn't the same as the total number of users of your app, because your users don't all connect at once. We encourage you to monitor your peak simultaneous database connections and upgrade or add more databases if needed.
On the last paragraph, what does it mean by adding more databases? Because as far as I know there is only one database in a project and multiple nodes inside that database. Does it mean creating multiple projects?
Yes, it means having a separate project as you can only have 1 database per project.
Update (2018 - 2019):
As of writing, Firebase now supports multiple Realtime Database instances per project. The database limits are now 100 for Spark, 200K for Flame and 200K per database for Blaze.
There can be multiple FirebaseApp instances. One will be initialised by default from the json file values, and the other you can create yourself, e.g.
FirebaseOptions options = new FirebaseOptions.Builder()
.setApplicationId("1:530266078999:android:481c4ecf3253701e") // Required for Analytics.
.setApiKey("AIzaSyBRxOyIj5dJkKgAVPXRLYFkdZwh2Xxq51k") // Required for Auth.
.setDatabaseUrl("https://project-1765055333176374514.firebaseio.com/") //Required for RTDB.
.build();
FirebaseApp.initializeApp(this /* Context */, options, "secondary"); //
Retrieve my other app.
FirebaseApp app = FirebaseApp.getInstance("secondary");
// Get the database for the other app.
FirebaseDatabase secondaryDatabase = FirebaseDatabase.getInstance(app);