Client-Server Architecture is very popular in distributed computing as it is suitable for wide variety of applications. The two major components of client/server model are a server and a client. Both the two components interact with each other through a network connection using a given protocol.
Client/server architecture is like a producer-consumer computing architecture where server acts as producer and client as a consumer. The connection is always unidirectional. First, the client issues a request to the server and after processing the request, the server response to the client. In this type of connection, there can also be multiple client requests to the same server that is passively waiting for them.
The important operations which are the part of the client-server paradigm are requested, accept (client side), and listen, response (server side). It can be easily understood with the definition of client-server architecture that server will be processing the request and client will be making the request.
The client-server model is suitable for many-to-one scenarios in which information and services are centralized and are associated through single access point: the server.
For both the client as well as server, there are two major models:
- Thin Client Model
- Fat Client Model/ Thick Client Model
Thin Client Model
In a thin-client model, the load of data processing and transformation of data is put on the server side and the client has a minimum implementation that is concerned with just retrieving and returning the data it is being asked for without any further processing.
In this type of model, the client component is also responsible for transforming and processing the data before returning it to the user. The server here features a relatively light implementation that is mostly concerned with the management of access to the data.
Components of Client-Server Model
The three components of a client-server model are:
- application logic
- data storage
In the thin-client model, the client only embodies the presentation component whereas server handles the other two i.e application logic and data storage.
In the fat-client model, client encapsulates presentation and most part of application logic, the server is responsible for the data storage and maintenance.
Presentation, application logic, and data storage can be considered as conceptual layers and most appropriately they can be called as tiers. The mapping between these conceptual layers and their implementation helps us to differentiate among several types of architectures. These can go under multitiered architectures.
Types of Client-Server Architectures
In the two-tier architecture, as the name suggests, the architecture portions the system into two tiers, these two components are located one on the client side and other on the server. The client is dually responsible for the presentation tier by providing a simple user interface; the server concentrates the application logic and data store into a single tier.
The server component in two-tier architecture is generally deployed on a powerful machine that is capable of handling and processing requests, accessing data and also executing the application logic to provide the client with a response. This type of system is much popular for those which has a limited size and suffers from scalability issues.
The disadvantage of this type of systems is that if the number of users increases, the performance of the server might dramatically decrease. The other limitation can be maintaining the data, access and maintain which might be prohibitive for single computation node or too large for serving the client with satisfactory performance.
Three Tier Architecture/ N-tier Architecture
The three-tier architecture separates presentation logic, application logic, and data storage into three tiers. This architecture is also generalized as N-tier architecture in case it is necessary to further divide the storage composing of application logic and storage tiers.
N-tier architecture which is explained in the diagram is generally more scalable than the two-tier architecture because it is possible with N-tier architecture to distribute the tiers into several computing nodes, thus removing the performance bottleneck.
Systems are also more complex to understand and manage as compared to two-tier architectures. An example of three-tier architecture can be a simple web application that relies on RDBMS (Relational Database Management System) for storing data.
In the above example, the client component is represented by the web browser which embodies the presentation tier and application server encapsulates database server machine and business logic tier.
The client-server model is one of the most important and has been the dominant reference model for designing and deploying many complex distributed systems. This model is generally suitable in case of the many-to-one scenario where interaction is unidirectional.
Advantages of Client-Server Architecture
- Single server is enough to handle all the requests of the client. The client can access the resources from any geographical location.
- Systems connected in this architecture are easily scalable and you can add resources in the form of network segments, servers or computers. The configuration of new resources is simple and can be managed easily.
- The overall cost of establishing the system is low.
- Sharing of data is easy.
- Maintenance of resource is not much difficult.
Disadvantages of Client-Server Architecture
- One of the biggest disadvantages of client-server architecture is that it is having a centralized server. There is always a chance that the failure of the server.
- Overloading of servers can be a big problem as the client requests increases, the overall performance can be reduced drastically.
- The system is not robust due to a centralized architecture.