Client-server

From Wikipedia, the free encyclopedia

Client-server is a computing architecture which separates a client from a server, and is almost always
implemented over a computer network. Each client or server connected to a network can also be referred to as
a node. The most basic type of client-server architecture employs only two types of nodes: clients and servers.
This type of architecture is sometimes referred to as two-tier. It allows devices to share files and resources.

Each instance of the client software can send data requests to one or more connected servers. In turn, the
servers can accept these requests, process them, and return the requested information to the client. Although
this concept can be applied for a variety of reasons to many different kinds of applications, the architecture
remains fundamentally the same.

These days, clients are most often web browsers, although that has not always been the case. Servers typically
include web servers, database servers and mail servers. Online gaming is usually client-server too. In the
specific case of MMORPG, the servers are typically operated by the company selling the game; for other
games one of the players will act as the host by setting his game in server mode.

The interaction between client and server is often described using sequence diagrams. Sequence diagrams are
standardized in the Unified Modeling Language.

Contents
• 1 Characteristics
o 1.1 Characteristics of a client
o 1.2 Characteristics of a server
• 2 Multi-tiered architecture
• 3 Comparison to Peer-to-Peer Architecture
• 4 Comparison to Client-Queue-Client Architecture
• 5 Advantages
• 6 Disadvantages
• 7 Examples
• 8 Notes
• 9 See also

Characteristics
Characteristics of a client

• Request sender is known as client

• Initiates requests
• Waits for and receives replies.
• Usually connects to a small number of servers at one time
• Typically interacts directly with end-users using a graphical user interface
Characteristics of a server

• Receiver of request which is send by client is known as server

• Passive (slave)
• Waits for requests from clients
• Upon receipt of requests, processes them and then serves replies
• Usually accepts connections from a large number of clients
• Typically does not interact directly with end-users

Multi-tiered architecture
Some designs are more sophisticated and consist of three different kinds of nodes: clients, application servers
which process data for the clients, and database servers which store data for the application servers. This
configuration is called a three-tier architecture, and is the most commonly used type of client-server
architecture. Designs that contain more than two tiers are referred to as multi-tiered or n-tiered.

The advantages of n-tiered architectures is that they are far more scalable, since they balance and distribute the
processing load among multiple, often redundant, specialized server nodes. This in turn improves overall
system performance and reliability, since more of the processing load can be accommodated simultaneously.[1]

The disadvantages of n-tiered architectures include:

1. More load on the network itself, due to a greater amount of network traffic.
2. More difficult to program and test than in two-tier architectures because more devices have to
communicate in order to complete a client's request.

Comparison to Peer-to-Peer Architecture

Another type of network architecture is known as peer-to-peer, because each node or instance of the program
can simultaneously act as both a client and a server, and because each has equivalent responsibilities and
status. Peer-to-peer architectures are often abbreviated using the acronym P2P.

Both client-server and P2P architectures are in wide usage today.

Comparison to Client-Queue-Client Architecture

While classic Client-Server architecture requires one of communication endpoints to act as a server, which is
much harder to implement, Client-Queue-Client allows all endpoints to be simple clients, while the server
consists of some external software, which also acts as passive queue (one software instance passes its query to
another instance to queue, e.g. database, and then this other instance pulls it from database, makes a response,
passes it to database etc.). This architecture allows greatly simplified software implementation. Peer-to-Peer
architecture was originally based on Client-Queue-Client concept.

Advantages
• In most cases, client-server architecture enables the roles and responsibilities of a computing system to
be distributed among several independent computers that are known to each other only through a
network. This creates an additional advantage to this architecture: greater ease of maintenance. For
example, it is possible to replace, repair, upgrade, or even relocate a server while its clients remain
 both unaware and unaffected by that change. This independence from change is also referred to as
encapsulation.
• All the data is stored on the servers, which generally have far greater security controls than most
clients. Servers can better control access and resources, to guarantee that only those clients with the
appropriate permissions may access and change data.
• Since data storage is centralized, updates to those data are far easier to administer than would be
possible under a P2P paradigm. Under a P2P architecture, data updates may need to be distributed and
applied to each "peer" in the network, which is both time-consuming and error-prone, as there can be
thousands or even millions of peers.
• Many mature client-server technologies are already available which were designed to ensure security,
'friendliness' of the user interface, and ease of use.
• It functions with multiple different clients of different capabilities.

Disadvantages
• Traffic congestion on the network has been an issue since the inception of the client-server paradigm.
As the number of simultaneous client requests to a given server increases, the server can become
severely overloaded. Contrast that to a P2P network, where its bandwidth actually increases as more
nodes are added, since the P2P network's overall bandwidth can be roughly computed as the sum of
the bandwidths of every node in that network.
• The client-server paradigm lacks the robustness of a good P2P network. Under client-server, should a
critical server fail, clients’ requests cannot be fulfilled. In P2P networks, resources are usually
distributed among many nodes. Even if one or more nodes depart and abandon a downloading file, for
example, the remaining nodes should still have the data needed to complete the download.

Examples
Imagine you are visiting eCommerce web site. In this case, your computer and web browser would be
considered the client, while the computers, databases, and applications that make up the online store would be
considered the server. When your web browser requests specific information from the online store, the server
finds all of the data in the database needed to satisfy the browser's request, assembles that data into a web page,
and transmits that page back to your web browser for you to view.

Specific types of clients include web browsers, email clients, and online chat clients.

Specific types of servers include web servers, ftp servers, application servers, database servers, mail servers,
file servers, print servers, and terminal servers. Most web services are also types of servers.

Notes
1. ^ This form of scalability is called horizontal scalability. There is substantial and growing criticism
that horizontal scalability is limiting as applications become more complex and interdependent,
particularly in the areas of network latency, reliability, and manageability. IBM, in particular, takes
this view and promotes both vertical and horizontal scalability. Vertical scalability implements fewer
servers able to support multiple application and database tiers, and multiple applications, concurrently.
The IBM System z is the most notable example of a vertically scalable system.