Question

Typically I use a database such as MySQL or PostGreSQL on the same machine as the application using it, which makes access easy and secure. I’m just now building the first site that will have a separate physical database server (later this year it will). I’m wondering 3 things:

1. (security) What things should I look into for starters pertaining to security of accessing a separate machine’s database?
2. (scalability) Are their scalability issues that I should think about pertaining to this (technology agnostic)?
3. (more ServerFaultish but related) If starting the DB out on the same physical server (using a separate VMWare VM) and later moving to a different physical server, are there implicit problems that I’ll have to deal with? Isn’t another VM still accessed via localhost?

If these questions are completely ludicrous, I apologize to you DB experts.

Answer 1

Easy, I’ll grant you. Secure.. well, security has very little to do with the physical location of the database server.

To get to your three questions though:

1. First, look at how you can limit access to database tables using the database servers security model. Namely, if your application does not need to drop tables, make sure the user it uses to connect does not have that ability. Second, look into how to encrypt the connection between the database server and your application. In windows this is pretty transparent through kerberos and can even be enforced by group policy settings, not sure about other platforms. Third, look into what features the database has for encrypting the data “at rest”. Meaning, does it natively support encryption of the actual data files themselves?

The point here is that your application is only one possible entry point to the database server itself. Ask yourself, what would happen if someone can connect directly without going through your application using your apps credentials. Next ask, what can happen if they find a SQL Injection issue.. Also, ask yourself, what information can be gleaned if someone is able to monitor the IP traffic going between your app and the server. Can they discern any data? Finally, ask yourself, what if they get a copy of the database itself?

The lengths you go for #1 is going to be dependent on several factors such as How valuable is the data (eg: what would happen to you, your company, or your clients if it was lost); and, How much time do you have to come up with an ideal solution?

2. scalability: This is purely a function of load. Unfortunately, the only way to scale most database applications is to scale up. Meaning that you acquire a larger database server as the need arises. Stack Overflow went through this not too long ago. Some database types (nosql, mongodb, etc) support a concept known as shredding or sharding. MySql, PostGreSql, etc don’t. Instead you’ll have to specifically design the app to handle it. Which means not using things like auto incrementing keys, etc. This can be a royal PITA… which is why scaling up is a much easier prospect depending on your application.

3. Another VM is not accessible via “localhost”. localhost defines access to your current server. Whether that server is a VM or not is immaterial. You’ll have to reference your database server by name. Now, transitioning the database VM to another physical server should have zero impact as your are referencing it by name. Beyond that there aren’t any other considerations.