What is multitenancy?

In cloud computing, multitenancy means that multiple customers of a cloud vendor are using
the same computing resources. Despite the fact that they share resources, cloud customers are
not aware of each other, and their data is kept totally separate. Multitenancy is a crucial
component of cloud computing; without it, cloud services would be far less practical.
Multitenant architecture is a feature in many types of public cloud computing,
including IaaS, PaaS, SaaS, containers, and serverless computing.

To understand multitenancy, think of how banking works. Multiple people can store their
money in one bank, and their assets are completely separate even though they are stored in
the same place. Customers of the bank do not interact with each other, do not have access to
other customers' money, and are not even aware of each other. Similarly, in public
cloud computing, customers of the cloud vendor use the same infrastructure – the same
servers, typically – while still keeping their data and their business logic separate and secure.
The classic definition of multitenancy was a single software instance* that served multiple
users, or tenants. However, in modern cloud computing, the term has taken on a broader
meaning, referring to shared cloud infrastructure instead of just a shared software instance.
*A software instance is a copy of a running program loaded into random access memory
(RAM).
Multi-tenancy is an architecture in which a single instance of a software application serves
multiple customers. Each customer is called a tenant. Tenants can be given the ability to
customize some parts of the application, such as the color of the user interface or business
rules, but they can't customize the application's code.
In a multi-tenant architecture, multiple instances of an application operate in a shared
environment. This architecture is able to work because each tenant is integrated physically
but is logically separated. This means that a single instance of the software will run on one
server and then serve multiple tenants. In this way, a software application in a multi-tenant
architecture can share a dedicated instance of configurations, data, user management and
other properties.
Multi-tenancy applications can share the same users, displays, rules and database schemas.
Users can customize the rules to an extent and the database schemas.
Importance of multi-tenancy
Multi-tenancy is an old idea and traces its roots to classical mainframe architectures where
many apps and users shared a common computing hardware platform. With the
reintroduction and broad adoption of modern hardware-assisted virtualization, the ability to
share hardware among multiple software instances -- such as virtual machines (VMs) and
their applications -- placed a new emphasis on multi-tenancy capabilities. The technique
gained popularity across local data centers and within hosted infrastructures normally
associated with colocation and other shared IT services -- all enabling many users to share
limited or common hardware infrastructure.
More recently, multi-tenancy has seen its most dramatic adoption with cloud computing.
Multi-tenant architectures are found in both public cloud and private cloud environments,
enabling each tenant's data to be separated from other tenants. For example, in a multi-tenant
public cloud, the same servers will be used in a hosted environment to host multiple users.
Each user is given a separate and ideally secure logical space within those servers to run
applications and store data.
Multi-tenancy is also important for the scalability of public and private clouds and has helped
make multi-tenancy a standard. The multi-tenant architecture can also help provide a better
ROI for organizations, as well as accelerate the pace of maintenance and updates for tenants.
Types of multi-tenant architecture
There are three main multi-tenancy model types, all with varying levels of complexity and
costs. Each model is traditionally discussed in terms of application and database -- the data
used by the application -- relationships.
Single application, single database. A single, shared database schema is a multi-tenancy
model with a multi-tenant database. This is the simplest form out of the three model types
and has a relatively low cost for tenants because of the use of shared resources. This form
uses a single application and database instance to host multiple simultaneous tenants and
store data. Using a single, shared database schema enables easier scaling; however,
operational costs can be higher and noisy neighbor effects can potentially affect performance.
Single application, multiple database. This multi-tenant architecture includes the use of a
single database with multiple schemas. This tenant system uses a single application instance
with individual databases for each tenant. In addition, this architecture is more difficult to
scale and has a higher cost and more overhead with each database. It's a valuable architecture
when data from different tenants need to be treated differently -- such as if they had to go
through different regulations per geographic region. Separate databases also help to reduce
potential noisy neighbor effects.
Multiple application, multiple database. This type of multi-tenant architecture hosts data in
multiple databases. This model is relatively complex in terms of cost, management and
maintenance, but the approach is secure and tenants can be separated by a chosen criterion.
How does work?
Here we will take a more in-depth look at the technical principles that make multitenancy
possible in different kinds of cloud computing.
In public cloud computing
Imagine a special car engine that could be shared easily between multiple cars and car
owners. Each car owner needs the engine to behave slightly differently: some car owners
require a powerful 8-cylinder engine, while others require a more fuel-efficient 4-cylinder
engine. Now imagine that this special engine is able to morph itself each time it starts up so
that it can better meet the car owner's needs.
This is similar to the way many public cloud providers implement multitenancy. Most cloud
providers define multitenancy as a shared software instance. They store metadata* about each
tenant and use this data to alter the software instance at runtime to fit each tenant's needs. The
tenants are isolated from each other via permissions. Even though they all share the same
software instance, they each use and experience the software differently.
*Metadata is information about a file, somewhat like the description on the back of a book.
In container architecture
Containers are self-contained bundles of software that include an application, system
libraries, system settings, and everything else the application needs in order to run.
Containers help ensure that an application runs the same no matter where it is hosted.
Containers are partitioned from each other into different user space environments, and each
container runs as if it were the only system on that host machine. Because containers are self-
contained, multiple containers created by different cloud customers can run on a single host
machine.
In serverless computing
Serverless computing is a model in which applications are broken up into smaller pieces
called functions, and each function only runs on demand, separately from the other functions.
(This model of cloud computing is also known as Function-as-a-Service, or FaaS.)
As the name implies, serverless functions do not run on dedicated servers, but rather on any
available machine in the serverless provider's infrastructure. Because companies are not
assigned their own discrete physical servers, serverless providers will often be running code
from several of their customers on a single server at any given time – another example of
multitenancy.
Some serverless platforms use Node.js for executing serverless code. The Cloudflare
serverless platform, Cloudflare Workers, uses Chrome V8, in which each function runs in its
own sandbox, or separate environment. This keeps serverless functions totally separate from
each other even when they’re running on the same infrastructure.
In private cloud computing
Private cloud computing uses multitenant architecture in much the same way that public
cloud computing does. The difference is that the other tenants are not from external
organizations. In public cloud computing, Company A shares infrastructure with Company B.
In private cloud computing, different teams within Company A share infrastructure with each
other.
Benefits of multitenant architecture
Multitenancy has a whole array of advantages, which are evident in the popularity of cloud
computing.
Multitenancy can save money. Computing is cheaper at scale, and multitenancy allows
resources to be consolidated and allocated efficiently, ultimately saving operational costs. For
an individual user, paying for access to a cloud service or a SaaS application is often more
cost-effective than running single-tenant hardware and software.
Multitenancy enables flexibility. If you’ve invested in your own hardware and software, it
might reach capacity during times of high demand or sit idle during times of slow demand. A
multitentant cloud, on the other hand, can allocate a pool of resources to the users who need
it, as their needs scale up and down. As a customer of a public cloud provider, you can access
extra capacity when you need it, and not pay for it when you don’t.
Multitenancy can be more efficient. Multitenancy reduces the need for individual users to
manage infrastructure and handle updates and maintenance. Individual tenants can rely on a
central cloud provider, rather than their own teams, to handle those routine chores.
Better use of resources: One machine reserved for one tenant is not efficient, as that one
tenant is not likely to use all of the machine's computing power. By sharing machines among
multiple tenants, use of available resources is maximized.
Lower costs: With multiple customers sharing resources, a cloud vendor can offer their
services to many customers at a much lower cost than if each customer required their own
dedicated infrastructure.
Drawbacks of multitenancy?
Possible security risks and compliance issues: Some companies may not be able to store data
within shared infrastructure, no matter how secure, due to regulatory requirements.
Additionally, security problems or corrupted data from one tenant could spread to other
tenants on the same machine, although this is extremely rare and should not occur if the cloud
vendor has configured their infrastructure correctly. These security risks are somewhat
mitigated by the fact that cloud vendors typically are able to invest more in their security than
individual businesses can.
The "noisy neighbor" effect: If one tenant is using an inordinate amount of computing power,
this could slow down performance for the other tenants. Again, this should not occur if the
cloud vendor has set up their infrastructure correctly.