Last time I talked about storage robustifiers.
In the context of a couple applications with which I am familiar, I want to discuss ways to approach balancing storage types and allocations.
Core requirements of any modern server, from a storage standpoint, are the following:
- Base OS storage
- OS/application log storage
- Application storage
Of course, many more elements couldÂ be added – but these are the ones I am going to consider today. From a cost perspective, hardware is almost alwaysÂ the least expensive part of an application deployment – licensing, development, maintenance, and other non-“physical” costs will typically farÂ outweigh the expenses of hardware.
RAM is cheap, comparatively. Any modern OS will lap-up as much memory as is given to it, so I always try to err on the side of generous.
After having found an instance where Swap Really Matteredâ„¢, I alwaysÂ follow the Red Hat guidelines which state that swap space should be equal to installed RAM plus 2 gigabytes. For example, if 16GB of RAM is installed, swap should at least equal 18GB. Whether swap should be on a physical disk or in a logical volume is up for debate, but do not chintz on swap! It is vital to the healthy operation of almost all modern systems!
This will vary on a per-platform basis, but a common rule-of-thumb is that Linux needs about 10GB for itself. Windows 2008 R2 requests a minimum of 20GB, but 40GB is substantially better.
Here is another wild variable -Â thoughÂ most applications have pretty predictable log storage requirements. For example, HP’s Server Automation (HPSA) tool will rarely exceed 10GB in total log file usage. Some things, like Apache, may have varying log files depending on how busy a website is.
Lastly, and definitely most importantly, is the discussion surrounding the actual space needed for an application to be installed and run. On two ends of the spectrum, I will use Apache and HPSA for my examples.
The Apache applicationÂ only requires a few dozen megabytes to install and run. The contentÂ served-up by Apache can, of course, be a bigÂ variable – a simple, static website might only use a few dozen megabytes. Whereas a big, complex website (like StackOverflow) might be using a few hundred gigabytes (in total with any dynamically-generated content which might be in a database, or similar)*.
The best way to address varying storage needs, in my opinion, is to use a robustifying tool like LVMÂ – take storage presented to the server, and conglomerate it into a single mount point (perhaps
/var/www/html) so that as content needs change, it can be grown transparently to the website.
Likewise, with HPSA, there are several base storage needs – for Oracle, initial software content, the application itself, etc. Picking-up on a previous post on bind mounts, I think it a Very Good Thingâ„¢ to present a mass of storage to a single initial mount point, like
/apps, and then put several subdirectories in place to hold the “actual” application. Storage usage for the “variables” of HPSA – Software Repository, OS Media, Model Repository (database) – is very hard to predict, but a base guideline is that you need 100GB in total to start.
Choosing Storage Types
This is how IÂ like to approach storage allocation on a physical server (virtual machines are a whole other beast, which I’l address in a future post) for HP Server Automation:
I firmly believe this should be put on local storage – ideally a pair of mirror RAIDed 73GB drives (these could be SSDs, to accelerate boot time, but otherwise the OS, per se, should not be being “used” much. You could easily get away with 36GB drives, but since drives areÂ cheap, using slightlyÂ moreÂ than you “need” is fine.
Again, following the Red Hat guidelines (plus my patented
fudge growth factor), ideally I want swap to be on either a pair of 36GB or a pair of 73GB drives – not RAIDed (neither striping, nor mirroring swap makes a great deal of sense). Yes, this means you should create a pair of swap partitions and present the whole shebang to the OS.
Maybe this is a little paranoid, but I like to have at leastÂ 30GB for log space (
/var/log). I view logs to be absolutely vital in the monitoring and troubleshooting arenas, so don’t chintz here!
HPSA has four main space hogs, so I’ll talk about them as subheadings.
It is important that the database has plentyÂ of space – start at 200GB (if possible), and present it as a logically-managed volume group, preferably made up of one or more [growable] LUNs from a SAN.
Note: Thin-provisioning is a perfectly-acceptable approach to use, by the way (thin provisioning present space as “available” but not yet “allocated” from the storage device to the server).
The application really doesn’t grow thatÂ much over time (patches and upgrades doÂ cause growth, but they are pretty well-defined).
Since this is the case, carve 50-60GB and present it as a [growable] LUN via LVM to the OS.
Depending on data retention policies, number of distinct OS flavors you need to deploy, and a few other factors, it is a Good Ideaâ„¢ to allocate a minimum of 40GB for holding OS media (raw-copied content from vendor-supplied installation ISOs). RHEL takes about 3.5GB per copy, and Windows 2008 R2 takes about the same. Whether this space is presented as an NFS share from a NAS, or as a [growable] LUN under an LVM group from a SAN isn’t vitally-important, but having enough space most certainly is.
This is truly the biggest wildcard of them all – how many distinct packages do you plan to deploy? How big are they? How many versions needs to be kept? How many target OSes will you be managing?
I prefer to startÂ with 50GB available to the Library. But I also expect that usage to grow rapidlyÂ once the system is in live use – Software Libraries exceeding 300GB are notÂ uncommon in my field. As with the OS Media discussion, it isn’t vitally-important whether this space is allocated from a NAS or a SAN, but it definitely needs to be growable!
Closing comments (on HPSA and storage)
If separate storage options are not available for the big hogs of SA, allocating one, big LVM volume (made up of LUNs and/or DAS volumes), and then relying on bind mounts is a great solution (and avoids the issue of needing to worry about any given chunk of the tool exceeding its bounds too badly – especially if otherÂ partsÂ aren’t being as heavily-used as might have been anticipated).
*Yes, yes, I know – once you hit a certain size, the presentation and content layers should be split into separate systems. For purposes of this example, I’m leaving it all together.