Four Types of
Distributed Systems
Under the umbrella of distributed systems,
there are a few different architectures. Broadly, we can divide distributed
cloud systems into four models:
Client-Server Model
In this model, the client fetches data from
the server directly then formats the data and renders it for the end-user. To
modify this data, end-users can directly submit their edits back to the server.
For example, companies like Amazon that store
customer information. When a customer updates their address or phone
number, the client sends this to the server, where the server updates the
information in the database.
Three-Tier Model
The three-tier model introduces an additional
tier between client and server — the agent tier.
This middle tier holds the client data,
releasing the client from the burden of managing its own information. The
client can access its data through a web application, typically. Through this,
the client application’s and the user’s work is reduced and automated easily.
For example, a cloud storage space with the
ability to store your files and a document editor. Such a storage solution can
make your file available anywhere for you through the internet, saving you from
managing data on your local machine.
Multi-Tier Model
Enterprises need business logic to interact
with various backend data tiers and frontend presentation tiers. This logic
sends requests to multiple enterprise network services easily. That’s why large
organizations prefer the n-tier or multi-tier distributed computing model.
For example, an enterprise network with
n-tiers that collaborate when a user publishes a social media post to multiple
platforms. The post itself goes from data tier to presentation tier.
Peer-to-Peer Model
Unlike the hierarchical client and server
model, this model comprises peers. Each peer can act as a client or server,
depending upon the request it is processing. These peers share their computing
power, decision-making power, and capabilities to work better in collaboration.
For example, blockchain nodes that collaboratively
work to make decisions regarding adding, deleting, and updating data in the
network.
