Basically when we talk about virtualization, we mean sharing resources. For sample, you can take VMware Workstation, install it to a windows machine, create a software container called “virtual machine” to this container and install one more Windows copy into this container. Now you have two instances of Windows running at the same time at the same hardware. One of them is running on hardware and the second one is running inside the software container.
Obviously, you could create several software containers and run several operating systems at once which is a way to multitenancy. The only limitation is your hardware.
The example above describes how does operating system level virtualization work. Each software container has it’s own copy of operating system. However this is not the only one possible virtualization way. Software container doesn’t have to have a copy of all the software it runs up to operating system files. In case you have tens of containers such a redundancy already will take you much RAM and disk space (and disk I/O which is even more critical).
Example products that provide operating system level virtualization:
- VMware Workstation
- Parallels Desktop
- Xen (used in Amazon EC2)
- Oracle VirtualBox
In order to reduce number of file duplicates on disk and in RAM, it may make sense to use another virtualization approach, which could allow to share common system libraries. Usually such an opportunity is called environment-level virtualization and it is build-in in modern operating systems under different ways, for sample:
- cgroups in Linux
- jails in FreeBSD
- containers in Solaris
And there are a number of wrappers for these technologies which provides a user-friendly interface and makes it possible for non-experienced system administrators, developers or even end-users to create software containers and run their applications in those containers.
As of 2015, my favorite “wrapper” for Linux cgroups is OpenShift.