High level question on mysql and connection pools (relating to AWS) - mysql

Question

I'm currently using AWS lambda to connect to an AWS mysql RDS. I'm creating a pool like such
pool = mysql.createPool({
host : 'host-details',
user : 'username',
password : 'password',
database : 'db'
});
Now when users of the app 'do something' it basically just connects via my code, grabs data out of the db table and then releases the connection. So let's say there are 10 users and they all simultaneously 'do something' Does that mean:
There will be 10 connections inside this pool and as soon as the connections release that connection count goes back to 0? If so does that mean this one pool (even if it had a limit of 50 connections) could support thousands of users as the DB queries last only few milliseconds?
Looking at the RDS monitoring in AWS, there is a metric for "DB connections (count)". Does the above scenario mean it would stay at 1 connection because it's 1 pool, or would it spike to 10 connections?
From my understanding, if my connection limit is 8 for the pool, and the above scenario occurs, the other 2 connections will queue. What stops me from setting the connection limit extremely high, is this just a factor of what the database can handle? ie if I see my DB memory/cpu performance starting to get into trouble, do I scale the pool connection limit back? and vice versa.
To cap this off, I'm trying to understand how this all works so I can setup my database / code properly so things don't break once it starts to scale.
Thank you.

Answer 1

Assuming you created the pool outside the Lambda handler, each instance of the function will create its own pool. Whenever a request comes in for a function, if there's no idle instance of the function, a new instance is created. Each instance creates its separate pool. A single instance can handle several invocations 1 at a time. All invocations of a single instance share the pool.
Answer to Q1:
Yes, that 1 pool can support 1000s of users if all the invocations triggered by those users end up being handled by a single instance of the function (1 at a time).
Answer to Q2:
The DB connections count metric of RDS would spike to 10. It counts the number of connections. It doesn't understand whether those connection originated in a pool.
Answer to Q3:
Set the connection limit based on your database instance size (CPU / memory) & how much traffic you expect to your Lambdas. So if your database can handle 200 connections at a time & you expect 10 instances of 1 Lambda to be running concurrently (& you only have 1 Lambda in total), set the pool size to 200/10 = 20. This is a very simplistic calculation. Many other factors like query duration would affect this.
For a pictorial view of all this, see my blog post.