In the past decade, IT systems have moved from monolithic mainframe-based systems to client/server systems, where the graphical user interface (GUI) is located in the client, while the business logic and main data storage is located in the server. For up to date Internet-enabled applications, a three-tier client/server architecture is normally used.
What Is A 3-Tier Architecture?
A 3-tier architecture is a type of software architecture that has three “tiers” or “layers” of logical computing. In 3-tier software architecture, there is an intermediary level, meaning the architecture is generally split up between:
A client, i.e. the computer, which requests the resources, equipped with a user interface (usually a web browser) for presentation purposes
The application server (also called middleware), whose task it is to provide the requested resources, but by calling on another server
The data server, which provides the application server with the data it requires
Generally, the 3-tier software architecture are often used in applications as a specific type of client-server system. A simple example of a 3-tier architecture in action would be customer service application for an electric utility - Employees answer phone calls from customers who are reporting problems with electric service. The user interface displays customer account and location information so a trouble ticket can be generated that contains information about the nearest lines, transformers, etc.. The application server accumulates and dispatches trouble tickets as well as caching customer account and system information from a 3rd tier mainframe database.
Breaking Down The Meaning Of 3 Tiers Architecture
Most users do not interact directly with a database system. The DBMS is hidden behind application programs, and there are lots of different systems implementing database applications. At an abstract level, however, these three-tier architecture systems which are still developed today all have the following components:
Client presentation Tier
The client presentation tier sometimes called the GUI or client view or front-end is the component responsible for communicating with the outside world. This tier is often built on web technologies such as HTML5, JavaScript, CSS, or through other popular web development frameworks, and communicates with others layers through API calls. The GUI is also implemented in this tier, either on a thin or a fat client. A “thin” client, such as a network computer, displays the application front end in a Web Browser, or an application specific GUI. A “fat” client, normally a PC, offers local data processing capabilities, besides providing the same functionality as a thin client.
The main functions of the Client presentation Tier are to translate tasks and results in something the user can understand. These include presenting information to external entities (may be humans or other systems), allowing the external entities to interact with the system, and handling the interaction with the user as it doesn’t contain business logic or data access code.
Application Logic Tier
Sometimes called middleware/back-end, this layer coordinates the application, processes commands makes logical decisions and evaluations, and performs calculations. It also moves and processes data between the two surrounding layers. Usually, a system does not just throw raw data at a user and write input directly to the database. Instead, the data is processed in some way before presenting or inserting it, and this is the job of the application logic tier.
It can accommodate many users and should not contain presentation or data access code. The application logic tier contains the functional business logic and dynamic content processing and generation level application server which drives an application’s core capabilities. It’s often written in Java, .NET, C#, Python, C++, etc.
Data Access Tier
Data Access Tier is a database, comprising both data sets and the database management system or RDBMS software that manages and provides access to the data. Sometimes called back-end or resource management layer, information is stored and retrieved from a database or file system in the Data Access Tier. The information is then passed back to the logic tier for processing, and then eventually back to the user. It is the physical storage layer for data persistence and manages access to DB or file system.
Examples of Data Access Tier systems are MySQL, Oracle, PostgreSQL, Microsoft SQL Server, MongoDB, etc. Data is accessed by the application layer via API calls.
Three-tier architectures separate all three layers from each other. This has several advantages which include the integration of different resources into a system, the movement of application logic to a different data access layer, the possibility of scaling the application logic and data access layers independently.
However, there is a disadvantage, and that is a communication overhead between application logic and data access layer.
3-Tier Software Architecture Principles
Each tier in the 3-tier software architecture (Presentation, Logic, Data) should be independent and should not expose dependencies related to the implementation. Unconnected tiers should not communicate, and the change in platform affects only the layer running on that particular platform.
The Benefits of Using a 3-Layer Architecture
There are many benefits to using the 3-tier layer software architecture, and these include:
Ease of maintenance
Components are reusable
Faster development (a division of work)
Complex application rules easy to implement
Superior performance for medium to high volume environments
Speed of development, scalability, performance, and availability.
Comparing 3-Tier Architecture To 2-Tier Architecture
The 2-tier architecture is a client-server architecture where the server is versatile, i.e. it is capable of directly responding to all of the client's resource requests.
Meanwhile, In 3-tier architecture, however, the server-level applications are remote from one another, i.e. each server is specialized with a certain task (for example web server/database server). 3-tier architectures provide many benefits for production and development environments by modularizing the user interface, business logic, and data storage layers. They provide a greater degree of flexibility, Increased security as security can be defined for each service and at each level, and Increased performance as tasks are shared between servers.
Wrapping Up
3-Tier Architecture will help improve development efficiency by allowing teams to focus on their core competencies. You no longer have to rely on full stack developers and can better utilize the specialities of each team for the front- end, server back-end, and data back-end development. The increased independence created when physically separating different parts of an application allows you to minimize performance issues when a server goes down.
Comments