Client-server

computing or networking is a distributed application architecture that partitions tasks

or work loads between service providers (servers) and service requesters, called
clients.[1] Often clients and servers operate over a computer network on separate
hardware. A server is a high-performance host that is a registering unit and shares its
resources with clients. A client does not share any of its resources, but requests a
server's content or service function. Clients therefore initiate communication sessions
with servers which await (listen to) incoming requests.

Description
Client-server describes the relationship between two computer programs in which one
program, the client program, makes a service request to another, the server program. Standard
networked functions such as email exchange, web access and database access, are based on
the client-server model. For example, a web browser is a client program at the user computer
that may access information at any web server in the world. To check your bank account from
your computer, a web browser client program in your computer forwards your request to a
web server program at the bank. That program may in turn forward the request to its own
database client program that sends a request to a database server at another bank computer to
retrieve your account balance. The balance is returned to the bank database client, which in
turn serves it back to the web browser client in your personal computer, which displays the
information for you.
The client-server model has become one of the central ideas of network computing. Many
business applications being written today use the client-server model. So do the Internet's
main application protocols, such as HTTP, SMTP, Telnet, DNS. In marketing, the term has
been used to distinguish distributed computing by smaller dispersed computers from the
"monolithic" centralized computing of mainframe computers. But this distinction has largely
disappeared as mainframes and their applications have also turned to the client-server model
and become part of network computing.
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.
The most basic type of client-server architecture employs only two types of hosts: clients and
servers. This type of architecture is sometimes referred to as two-tier. It allows devices to
share files and resources. The two tier architecture means that the client acts as one tier and
application in combination with server acts as another tier.
The interaction between client and server is often described using sequence diagrams.
Sequence diagrams are standardized in the Unified Modeling Language.
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, name servers, mail servers, file servers, print servers, and terminal servers. Most web
services are also types of servers.

Comparison to peer-to-peer architecture

Another type of network architecture is known as peer-to-peer, because each host 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 by
P2P.
Both client-server and P2P architectures are in wide usage today. Details may be found in
Comparison of Centralized (Client-Server) and Decentralized (Peer-to-Peer) Networking.

Comparison to client-queue-client architecture

While classic client-server architecture requires one of the communication endpoints to act as
a server, which is much harder to implement, [citation needed] 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. Peerto-peer architecture was originally based on Client-Queue-Client concept.

Advantages

In most cases, a 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.
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 that data are far easier to administer than
what 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 clientserver paradigm. As the number of simultaneous client requests to a given server
increases, the server can become overloaded. Contrast that to a P2P network, where
its aggregated bandwidth actually increases as 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 clientserver, 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

Businesses of various sizes have various computer needs. Larger businesses necessarily
need to use more computers than smaller businesses do. Large businesses routinely have
large computer setups, such as mainframes and networks. A network for a large business
commonly has a client-server architecture, also known as a two-tier architecture. No matter
what it is called, this type of architecture is a division of labor for the computing functions
required by a large business.
Under the structure of the client-server architecture, a business's computer network will have
a server computer, which functions as the "brains" of the organization, and a group of client
computers, which are commonly called workstations. The server part of the client-server
architecture will be a large-capacity computer, perhaps even a mainframe, with a large
amount of data and functionality stored on it. The client portions of the client-server
architecture are smaller computers that employees use to perform their computer-based
responsibilities.
Servers commonly contain data files and applications that can be accessed across the
network, by workstations or employee computers. An employee who wants to access
company-wide data files, for instance, would use his or her client computer to access the data
files on the server. Other employees may use a common-access application by accessing the
server through their client computers.
This type of server is called an application server. It takes full advantage of the client-server
architecture by using the server as a storage device for applications and requiring the clients
to log in to the server in order to use those applications. Examples of this kind of application
are numerous; among the most popular are word processors, spreadsheets, and graphic design
programs. In each case, the use of the applications illustrates the client-server architecture.
The server is not just for storage, however. Many networks have a client-server architecture
in which the server acts as a processing power source as well. In this scenario, the client
computers are virtually "plugged in" to the server and gain their processing power from it. In
this way, a client computer can simulate the greater processing power of a server without
having the requisite processor stored within its framework. Here, the client-server
architecture describes a virtual sort of power plant.

The Client Server Architecture

The Internet revolves around the client-server architecture. Your computer runs software
called the client and it interacts with another software known as the server located at a
remote computer. The client is usually a browser such as Internet Explorer, Netscape
Navigator or Mozilla. Browsers interact with the server using a set of instructions called
protocols. These protocols help in the accurate transfer of data through requests from a
browser and responses from the server. There are many protocols available on the Internet.
The World Wide Web, which is a part of the Internet, brings all these protocols under one
roof. You can, thus, use HTTP, FTP, Telnet, email etc. from one platform - your web browser.

Some common Internet protocols

HTTP (HyperText transfer Protocol): used on the World Wide Web (WWW) for
transfering web pages and files contained in web pages such as images.
FTP (File Transfer protocol): employed for transfering files from one machine to the
other.

SMTP (Simple Mail Transport Protocol): used for email.

Telnet Protocol: Used to open telnet sessions.

The web employs a connection-less protocol, which means that after every client-server
interaction
the
connection
between
the
two
is
lost.
Let us now examine the client-server inter-communication with three models.

Model #1 of the client-server architecture - Static HTML

pages

The client (browser) requests for an HTML file stored on the remote machine through the
server software. The server locates this file and passes it to the client. The client then displays
this file on your machine. In this case, the HTML page is static. Static pages do not change
until the developer modifies them.

Model #2 of the client-server architecture - CGI Scripts

The scenario is slightly different for CGI applications. Here the server has to do more work
since CGI programs consume the server machine's processing power.
Let us suppose you come across a searchable form on a web page that runs a CGI program.
Let us also suppose you type in the word 'computers' as the search query. Your browser sends
your request to the server. The server checks the headers and locates the necessary CGI
program and passes it the data from the request including your search query "computers". The
CGI program processes this data and returns the results to the server. The server then sends
this formatted in HTML to your browser which in turn displays the HTML page.
Thus the CGI program generates a dynamic HTML page. The contents of the dynamic page
depend on the query passed to the CGI program.

Model #3 of the client-server architecture - Server side

scripting technologies

The third case also involves dynamic response generated by the use of server side
technologies.
There
are
many
server
side
technologies
today.
Active Server Pages (ASP): A Microsoft technology. ASP pages typically have the

extension
.asp.
Personal Home Pages (PHP): An open source technology. PHP pages typically have .php,
.phtml
or
.php3
file
name
extensions.
Java
Server
Pages:
.jsp
pages
contain
Java
code.
Server Side Includes (SSI): Involves the embedding of small code snippets inside the HTML
page. An SSI page typically has .shtml as its file extension.
With these server technologies it has become easier to maintain Web pages especially helpful
for a large web site. The developer needs to embed the server-side language code inside the
HTML page. This code is passed to the appropriate interpreter which processes these
instructions and generates the final HTML displayed by the browser. Note, the embedded
server-script code is not visible to the client (even if you check the source of the page) as the
server sends ONLY the HTML code.
Let's look at PHP as an example. A request sent for a PHP page from a client is passed to the
PHP interpreter by the server along with various program variables. The interpreter then
processes the PHP code and generates a dynamic HTML output. This is sent to the server
which in turn redirects it to the client. The browser is not aware of the functioning of the
server. It just receives the HTML code, which it appropriately formats and displays on your
computer.