The client is called server architecture. Various architectural solutions used when implementing multi-user databases. brief overview of subd

Client-server systems. Part 2

Client-server architecture: definition, prerequisites for application, pros and cons

What is client-server architecture? Application building options

So, let's finally talk about

What exactly is a client-server? . Strictly speaking, one should distinguish between client-server technology in a broad sense, which can be used in any computer systems from the client-server architecture itself in relation to information applications in general and automated enterprise management systems in particular.

According to the online dictionary of computer terms, client-server is a kind distributed system, in which there is a server that fulfills client requests, and the server and client communicate with each other using one or another protocol.

A client is a program that uses resources, and a server (in English, a servant) is a program that serves client requests for a certain type of resource. Such a broad definition includes almost any software technology that involves more than one program, the functions between which are distributed asymmetrically. Accordingly, they talk about CS technology in relation to operating systems, local and global networks etc.

Such a broad definition creates some confusion. Thus, a file-server system also uses client-server technology, but from the point of view of application program architecture, what is important is what kind of resources the server provides to clients.

The concept of client-server architecture in enterprise management systems is associated with the division of any application program into three main components or layers. These three components are

data presentation (visualization) component;

applied logic component;

database management component.

Indeed, any program that computerizes the execution of one or another applied problem, must exchange information with the user, carry out the actual processing of this information as part of the automation of a particular business process, and, finally, store the data used in the program on one or another permanent medium.

For local applications that run entirely on a PC (for example, Word or Excel), all these components are collected together and cannot be distributed between various computers. Such a program is monolithic and uses for execution only the resources of the computer on which it is executed.

In file-server applications, part of the storage component is transferred to the file server, however, all manipulations with data structures are performed on the client machine, and the user program code also runs only on it.

The criterion allowing to classify application programs To client-server architecture is that at least one of its three components runs entirely on another computer, and the interaction between the components on different computers carried out through one or another network environment by transmitting requests for a particular resource.

Since client-server architecture is a special case of client-server technology, it necessarily has a client and a server. Accordingly, the client and server sides of the application are distinguished. Client side The application operates at the user’s workplace, which in the vast majority of cases is a personal computer. Server side operates on a specialized complex that includes powerful hardware, the required set of standard software, a database management system and the data structures themselves.

The interaction between the client and server parts of the application is carried out through a network - local or global. At the same time, from the point of view of the client and server, interaction is carried out transparently, respectively network component here it includes a set of necessary network equipment, a set of software technologies that ensure data transfer between network nodes, as well as the actual protocol or protocols for exchanging requests and the results of their execution.

The application task visualization component provides information input by the user using certain means, as well as displaying information on the screen and printing. The visualization component for the client-server architecture is always executed at the user's workstation (since he must observe any results of the program).

The applied logic component actually solves one or another problem related to data processing in one or another subject area. This component can be distributed between the client and server in different ways depending on the model used.

The database storage component performs physical operations related to storing data, reading information from the database and writing to it. In a client-server architecture, this component always runs on the server.

In terms of the number of components, client-server systems are divided into two-level and three-level

. Two-level systems consist only of a client and a server. IN three-level Between the user client and the server that stores and processes the database, a third, intermediate layer appears, which is a server for the user and a client for the database management system. This architecture allows for more flexible distribution of system functions and load between components of the hardware and software complex, and can also reduce resource requirements for user workstations. The necessary price for this is that similar systems much more difficult to develop, implement and operate and require significant costs and highly qualified personnel.

The third part examines an example of a three-tier structure Baikonur Server.

In the client-server architecture, there are several different application models, depending on the distribution of application components between the client and server parts. Historically, the very first was developed server model remote access to data. In this model, the server part only stores data, and all application logic is implemented by the client part. In this case, the client will send requests to the server to obtain data, and the server will return certain samples to the client. The most common means of communication between the client and the server in this case is SQL (structured query language) - a standard non-procedural language focused on data processing.

In the remote data access server model, no application part of the system is executed on the server side, which can lead to underloading of the server and overload of the client. Therefore, it was subsequently proposed and then implemented database server architecture. In it, part of the application logic is implemented on the server, using special language programming, and part - on the client. This became possible thanks to the increased productivity of modern DBMS servers. Compared to the remote data access server option, in this case the load is slightly reduced

on the client side, the intensity of network data exchange, and in some cases the application structure is simplified. Currently, this option for building systems is the most common.

Another option for client-server architecture is applications server. In this case, the client performs only visualization and data entry operations, and the server implements all application logic. The exchange between the client and the server in such systems is carried out at the level of commands for displaying data on the screen and the results of user input. The most striking example of this architecture is the well-known web browser. Most often, in the application server model, the application logic and data management components are implemented separately.

Application server architecture is often referred to as "thin" client, Unlike a traditional "thick" client implemented in a database server architecture. A thin client is an option that can be used when the resources available at users' workstations are insufficient to execute application logic. In addition, this technology allows you to reduce the cost of operating client components of the system due to their strong simplification.

Prerequisites for the emergence of client-server architecture in the enterprise

Computerization of an industrial enterprise can take place for quite a long time within the framework of the previously described local workplaces or architecture file server. However, sooner or later there may come a time when the only option for further development automated enterprise management systems will become the architecture client-server. Let's try to list main reasons for which it becomes necessary.

Firstly, the client-server architecture becomes vital when the number of users simultaneously actively using the same data exceeds 10-15 people. Due to the fundamental limitations inherent in file server applications, such systems are difficult to tolerate with 15 concurrent users, and often fall apart with 20 users. Thus, if an enterprise is faced with the task of building a system in which the number of places simultaneously actively working with data exceeds 20, practically the only option for it is a client-server.

To be fair, it should be noted that mainframe computers are also able to cope with tens or even hundreds of users. However, due to the high cost of hardware, the high cost of development, and, importantly, the considerable costs of operating such equipment and programs for it, the option of using a centralized architecture when introducing new systems in our country is almost never considered.

Another critical point for the transition to a client-server architecture is the transition to solving enterprise-scale problems and managing the enterprise as a whole. Automation of individual jobs can be successfully performed even without using network technologies, a file server can handle department-scale tasks, but building an integrated automated system covering the entire enterprise or at least one of the management subsystems is only possible using client-server technologies.

Another situation where client-server is the only way to build a system is when the automated system has remote users, with whom it is necessary to exchange information in real time. By real time scale we mean seconds-minutes here. In this case, exchanging data on floppy disks is fundamentally unsuitable, and the file-server architecture will require very high exchange speeds, and this can be either fundamentally impossible or very expensive. Individual examples of wealthy organizations that built city-wide file server systems (for example, the Russian Inkombank) are exceptions that prove the rule.

And finally, client-server architecture is necessary when the task of ensuring information integrity becomes critical. By critical we mean a situation in which the cost of a data error can be comparable to the cost of creating a client-server system. First of all, this is relevant for financial services of enterprises.

An attempt to solve any of the problems listed above as part of the computerization of an industrial enterprise will necessarily entail the emergence of a client-server system. In addition, this architecture may emerge as a natural evolution of automated manufacturing control systems, even if the limitations of previous architectures in a given enterprise have not yet become critical. This option is the most preferable because, on the one hand, the implementation receives support from within, and, on the other hand, there is time to prepare a smooth change in the architecture of information applications.

Client-server architecture: Yes, but...

We have already talked about the advantages of client-server architecture. A natural question may arise: if it is so good, then why haven’t they switched to it yet? All major users of information systems. It's actually not that simple.

First of all, for domestic industrial enterprises it is critical cost factor. Unlike Western enterprises, where, as a rule, we are talking about replacing rather expensive centralized systems with client-server ones, the direct costs of which are lower, domestic enterprises almost never had enough funds to implement large centralized systems. Very often, the information systems available in an enterprise are built on outdated hardware that requires complete replacement when moving to a client-server architecture.

The next big "but" is the large volume of technological changes themselves problems that arise when trying to implement a client-server architecture. A client-server system requires a different level of technical literacy on the part of employees information services, and end users. The costs of retraining users and operating personnel, restructuring the enterprise automation structure make up a larger part of the iceberg than the clearly visible direct costs of upgrading equipment, purchasing and/or developing the required software.

And finally, the biggest pitfall on the way to creating a CS system at an enterprise is the need change the management structure and associated organizational costs

An attempt to introduce new technological solutions without changing anything in the essence of automated business processes may end in vain. In this case, the enterprise will suffer direct material losses due to the large volume of expensive hardware and software lying dead weight, as well as due to the distraction of employees from performing their main job duties. At best, they will be implemented separate areas client-server system, while actually new software will be used at the old ideological level.

If, after weighing all the pros and cons, the enterprise nevertheless decides to create a client-server system, then it faces the task component selection to build this system. Anyway necessary component is this or that database server corporate level. The remaining components depend on the path chosen by the enterprise for the further development of the automated control system.

If the enterprise has decided develop the system yourself, then he is faced, first of all, with the task of choosing development tools. If the company places order for the creation of a system a specific development company, then it faces a similar task.

In the event that a decision is made not to develop the system ourselves, but to use one of the solutions available on the market, then the main component of the choice is ready-made (to one degree or another) enterprise automation system. In fact, the word "off-the-shelf" should be used very carefully, since it is difficult to draw a clear line between customization for the needs of a specific use and adaptation of the system, which often includes modifying system modules or even developing additional software to meet the needs of the customer.

They are unequal components of the information network. Some own a resource and are therefore called servers; others access these resources and are called clients. Let's look at how they interact with each other and what the client-server architecture is.

Client-server architecture

The “Client-Server” architecture is the interaction of structural components in a network based on those defined by the network, where the structural components are the server and nodes that provide certain specialized functions (services), as well as clients who use this service. Specific functions are usually divided into three groups based on solving specific problems:

data input and presentation functions are designed for user interaction with the system;
applied functions - each has its own set;
resource management functions are designed to manage the file system, various databases data and other components.

For example, a computer without network connection,represents presentation, application, and control components at various levels. These levels include the operating system, application and utility software, and various utilities. In the same way, all the above components are presented on the Internet. The main thing is to properly ensure network interaction between these components.

How the client-server architecture works

Client-server architecture is most often used to create corporate databases in which information is not only stored, but also periodically processed using various methods. The database is the main element of any corporate information system, and the server houses the core of this database. Thus, the most complex operations related to data entry, storage, processing and modification take place on the server. When a user (client) accesses the database (server), the request is processed: directly accessing the database and returning a response (processing result). The result of processing is a network message about the success of the operation or an error. Server computers can handle simultaneous requests from multiple clients for the same file. Such work over the network allows you to speed up the work of the applications you use.

Client-server architecture: application of technology

This architecture is used to access various resources using network technologies: databases, mail servers, firewalls, proxy servers. Client development server applications allows you to improve the security, reliability and performance of your applications and the network as a whole. Client-server applications are most often used for business automation.

Development for iOS,

Mobile application development

Let me make a reservation right away that I am a mobile developer, and the article is intended mainly for developers on the other side of the cloud - mobile developers already know about all this. I wrote the last web application many years ago and I may be wrong in web terminology, may not know some of the latest trends in .NET, PHP or Java web services, so don't judge too harshly.

Like anyone front-end developer, in almost every project I have to deal with client-server protocols - I can’t do without them. And very, very often you have to work with poorly thought out architecture.

Also, very often the development of the protocol and architecture falls on the shoulders of the web developer, which is not always true - in most cases it should only be developed jointly with those who will adapt to this architecture. Unfortunately, having worked on several dozen projects over the past three years, I had the opportunity to participate in the planning of this section of the architecture only 3 or 4 times - in all other cases it was already provided in varying degrees of readiness by the customer. But how much better the world could be!

Error processing

Most often I came across something like this:

HTTP code 200 (OK) false The username or password is incorrect. Please try again.
Those. the result of processing the request is contained in the sent XML itself, the HTTP return code is 200, i.e. ok, the data is presented as a regular RPC. For example, error handling in the SOAP protocol is implemented in a similar way in 90% of cases.

In particularly advanced cases, especially typical for Indian code, false can be located in various places in the XML, which significantly complicates parsing, leads to overcomplication and brings immense joy to a bored programmer.

But let's look at the disadvantages of this approach in principle.

First, you have to parse XML. This is extra data transferred over the network, extra CPU time spent on XML parsing, extra RAM for storing text data. All this is not so scary modern devices V Wi-fi zone, but even such excesses can be important in the metro between stations in an application that sends dozens of requests simultaneously (and with this approach, empty blocks for error handling should be in every request, even successful ones).
Secondly, the web developer has to invent error texts himself. Very often they are completely incomprehensible to the user, because... accuracy of wording is the last thing a web developer thinks about when writing a service. The error text in 90% of cases does not agree with the native speakers and last but most important - great amount mobile applications need localization. While the error text is most likely always written only in English, therefore it is absolutely useless for a front-end programmer - he cannot simply take it and display it.

But the time needed by the web programmer to come up with the text of the message is wasted, and the channel is also loaded with unnecessary information.

How to solve a problem?

The HTTP protocol has been providing the ability to add your own error codes for many years; to do this, they simply must belong to the range from 512 to 597. I am sure that this number of errors will be enough to cover all possible errors in a medium sized application. It’s obvious what advantages this gives, but let’s summarize:

No redundancy. Only the HTTP code in the header is transmitted, there is simply no request body.
On the client side, there are only two branches of request processing code - successful execution or execution error (both callbacks are already implemented out of the box in any request library). There are no “request completed successfully, but there may be a logical error in the response body” threads.

5xx Server Error
The server failed to fulfill an apparently valid request.
Response status codes beginning with the digit “5” indicate cases in which the server is aware that it has encountered an error or is otherwise incapable of performing the request. Except when responding to a HEAD request, the server should include an entity containing an explanation of the error situation, and indicate whether it is a temporary or permanent condition. Likewise, user agents should display any included entity to the user. These response codes are applicable to any request method.

Those. clients must show the user the message sent by the server. It is immediately clear what the Americans wrote. The Russians, by the way, translated it stupidly.

Although we won’t generalize – the idea of using HTTP codes was suggested to me by an American several years ago.

In general, the ideology is this: the client always knows better how to report an error. And the server must inform the client about the error in the fastest and most cost-effective way.

Binding to a session or cookie.

This connection most likely occurs if a website was created first, and only then the customer decided to create a mobile frontend. Although working with session variables is possible on the mobile side, it is not good practice because Often there is no normal toolkit for working with these tools.

The second, global drawback is that Safari (or any browser on Android) does not share its cookies and session variables with the application, which, of course, is correct from a security point of view, but leads to a number of problems and crutches.

Let's say your mobile application implements only 70% of the functionality of the website. The remaining 30% of the functionality is available only on the web, and your application only contains links to relevant web pages.

It is also possible that these pages are only accessible to authorized users. As a result, the user who is already logged in mobile client, you will be asked to log in again - this time in an inconvenient web form, and happiness will be if after logging in the user is redirected to the desired section of the site.

Bottom line - if you're designing a generic protocol, forget about things like session variables and cookies. A much better way would be to pass some unique token received during authorization explicitly in the body of each request. And web pages and web applications should adapt to the use of a single API. I'm sure all mobile developers have often seen two versions of the API - one for web applications, the other for mobile applications. But this is duplication of functionality, which is always more expensive both at the development stage and at the debugging stage. It is always better to allocate web services into a separate layer of the system from the very beginning, rather than embed them in other parts close to web technologies.

Return HTML

This already leads back to the design of the web servers themselves, which were initially designed only for the browser. Errors 403, 404, and sometimes even more complex ones are very often presented in the form of an HTML page, which there is often simply no means to show in mobile application. More precisely, there are means, but when you see “404 page not found” in hefty black Arial Black on a white background inside the web view, mobile user will get scared and close the application.

Remember, the server must return XML (or JSON) for any call to web services, and only in the format that was originally agreed upon. A mobile developer can't do anything useful with the HTML that comes from the server.

Use WSDL

The situation with Microsoft technologies is still okay - most of their modern technologies support WSDL out of the box. The same cannot be said about PHP and Java - especially PHP developers love to manually create ordinary pages, which are essentially web services. But in order to integrate with a WSDL-compatible web service, a mobile developer only needs to use the tool to generate code, while manually compiled web service responses also need to be parsed by hand.

True, there are subtleties here too - standard WSDL implementations from MS and Sun (Oracle) still have incompatibilities, but it’s still faster to correct these incompatibilities with a file than to write everything manually.

Conclusion

I only touched on the most pressing design errors that mobile developers have to deal with every day. If the article is in demand, I will definitely write about a dozen more client-server subtleties that I would really like to see in the API of the web services that you work with every day.

File server architecture

Traditional information systems architectures.

Basic functions information systems.

Information system architecture- a concept that defines the model, structure, functions performed and interconnection of the components of an information system. (Glossary)

From point of view software and hardware implementation A number of typical IC architectures can be distinguished.

The components of an information system can be divided into three layers according to the functions they perform: a presentation layer, a business logic layer, and a data access layer.

Presentation Layer- everything related to interaction with the user: pressing buttons, moving the mouse, drawing an image, displaying search results, etc.

Business logic- rules, algorithms for the application’s response to user actions or internal events, data processing rules.

Data access layer- storage, retrieval, modification and deletion of data related to the application task being solved by the application

Local networks appeared. Files began to be transferred over the network. At first there were peer-to-peer networks - all computers have equal rights. 3

Then the idea arose of storing all publicly accessible files on a dedicated computer on the network - a file server.

File server applications- applications that are similar in structure to local applications and use a network resource to store programs and data. Server functions: storing data and program code. Client functions: data processing occurs exclusively on the client side.

The number of clients is limited to tens.

1. Multi-user mode for working with data;

2. Convenience of centralized access control;

3. Low development cost;

1. Low performance;

2. Low reliability;

3. Weak expansion capabilities;

The disadvantages of a file server architecture are obvious and stem mainly from the fact that data is stored in one place and processed in another. This means that they must be transmitted over the network, which results in very high network loads and, as a result, a sharp decrease in application performance as the number of concurrent clients increases. The second important disadvantage of this architecture is the decentralized solution to the problems of data integrity and consistency and simultaneous access to data. This solution reduces the reliability of the application.

The key difference between a client-server architecture and a file-server architecture is the abstraction from the internal data representation (physical data schema). Client programs now manipulate data at the logical circuit level.

So, the use of client-server architecture made it possible to create reliable (in terms of data integrity) multi-user information systems with a centralized database, independent of the hardware (and often software) part of the database server and supporting a graphical user interface (GUI) on client stations connected by a local network . Moreover, application development costs were significantly reduced.

Main features: 5

 The client program works with data through requests to the server software.

 The basic functions of the application are divided between the client and the server.

 Full support multi-user work

 Data integrity guarantee

 The business logic of the applications remained in the client software. With any change in algorithms, you need to update the user software on each client.

 High requirements for bandwidth communication channels with the server, which prevents the use of client stations other than in the local network.

 Weak protection data from hacking, especially from unscrupulous users of the system.

 High complexity of administration and configuration of system user workstations.

 The need to use powerful PCs at client sites.

 High complexity of system development due to the critical importance of executing business logic and providing the user interface in one program.

It is easy to see that most of the shortcomings of the classical or 2-layer client-server architecture stem from the use of the client station as the executor of the IS business logic. For this reason, an obvious step in the further evolution of IS architectures was the idea of a “thin client”, that is, dividing data processing algorithms into parts associated with the performance of business functions and associated with displaying information in a human-friendly presentation. At the same time, only the second part is left on the client machine, associated with the primary verification and display of information, transferring all the real functionality of the system to the server part.

Transitional to three-layer architecture (2.5 layers)

Using stored procedures and server-side data calculation reduces traffic and increases security. The client still implements part of the business logic.

As you can see, this organization of the system is very reminiscent of the organization of the first unitary systems, with the only difference that at the user’s place there is not a terminal (with the notorious green screen), but a personal computer that provides a GUI, for example, in Lately Standard www browsers are often used as client programs. Of course, such a return to almost unitary systems occurred at a different technological level. The use of DBMS with all its advantages has become mandatory. Programs for the server side are written mainly in specialized languages, using the mechanism of stored procedures of the database server. However, at the level of logical organization, the IS in the client-server architecture with a thin client is split into three layers - a data layer, a layer of business functions (stored procedures) and a presentation layer. Unfortunately, usually, in such an IS design scheme, it is not possible to write all the business logic of the application in built-in DBMS languages not intended for this purpose. For this reason, very often part of the business functions is implemented in the client part of the systems, which inevitably “gets fatter” as a result. Partly because of this, and partly because such ICs physically consist of two components, this architecture is often called a 2.5-layer client-server architecture.

Unlike 2-layer architecture, 2.5-layer architecture usually does not require high-speed communication channels between the client and server parts of the system, since ready-made calculation results are transmitted over the network - almost all calculations are performed on the server side. Information protection is also significantly improved - users are given rights to access the functions of the system, and not to access its data, etc. At the same time, along with the advantages of the unitary approach, architecture 2.5 also adopts all its disadvantages, such as: limited scalability, dependence on software platform, limited use network computing resources. In addition, programs for the server part of the system are written in stored procedure languages built into the DBMS, intended for data validation and building simple reports, and not at all for writing enterprise-scale IS. All this reduces the performance of the system, increases the complexity of creating and modifying the IC, and has the most negative impact on the cost of the hardware necessary for its operation.

Send your good work in the knowledge base is simple. Use the form below

Students, graduate students, young scientists who use the knowledge base in their studies and work will be very grateful to you.

Posted on http://www.allbest.ru/

1. Servers. Server Basics

2. Client-server model

3. Classification of standard servers

1. Servers. Server Basics

Server (from the English server, serving). Depending on the purpose, there are several definitions of the concept server.

1. Server (network) - a logical or physical network node that serves requests to one address and/or domain name (adjacent domain names), consisting of one or a system of hardware servers on which one or a system of server programs are executed

2. Server (software) - software that receives requests from clients (in client-server architecture).

3. Server (hardware) - computer (or special computer equipment) dedicated and/or specialized to perform certain service functions.

3. Server in information technology-- software component computing system, performing service functions at the request of the client, providing him with access to certain resources.

Interrelation of concepts. A server application (server) runs on a computer, also called a “server”, and when considering the network topology, such a node is called a “server”. IN general case it may be that the server application is running on a regular workstation, or a server application running on a server computer within the topology in question acts as a client (that is, it is not a server from the point of view of the network topology).

2. Client-server model

A client-server system is characterized by the presence of two interacting independent processes - a client and a server, which, in general, can be executed on different computers, exchanging data over the network.

Processes that implement some service, such as a service file system or databases are called servers(servers). Processes that request services from servers by sending a request and then waiting for a response from the server are called clients(clients) .

According to this scheme, data processing systems based on DBMS, mail and other systems can be built. We will talk about databases and systems based on them. And here it will be more convenient not just to consider the client-server architecture, but to compare it with another - file-server.

In a file server system, data is stored on a file server (for example, Novell NetWare or Windows NT Server), and its processing is carried out on workstations, which, as a rule, operate one of the so-called “desktop DBMSs” - Access, FoxPro , Paradox, etc..

The application on the workstation is “responsible for everything” - for creating the user interface, logical data processing and for direct data manipulation. File server provides services only low level- opening, closing and modifying files. Please note - files, not databases. The database management system is located on the workstation.

Thus, several independent and inconsistent processes are involved in the direct manipulation of data. In addition, to carry out any processing (search, modification, summation, etc.), all data must be transferred over the network from the server to the workstation ( see fig. Comparison of file-server and client-server models)

Rice. Comparison of file-server and client-server models

In a client-server system, there are (at least) two applications - a client and a server, sharing among themselves those functions that, in a file-server architecture, are performed entirely by an application on a workstation. Data storage and direct manipulation is carried out by a database server, which can be Microsoft SQL Server, Oracle, Sybase, etc..

The user interface is created by the client, for the construction of which you can use a number of special tools, as well as most desktop DBMSs. Data processing logic can be executed on both the client and the server. The client sends requests to the server, usually formulated in SQL. The server processes these requests and sends the result to the client (of course, there can be many clients).

Thus, one process is responsible for directly manipulating the data. At the same time, data processing occurs in the same place where the data is stored - on the server, which eliminates the need to transfer large amounts of data over the network.

What does client-server architecture provide?

Let's look at this architecture in terms of business needs. What qualities does a client-server bring to an information system?

Reliability

The database server performs data modification based on a transaction mechanism, which gives any set of operations declared as a transaction the following properties:

· atomicity- under any circumstances, either all transaction operations will be performed or none will be performed; data integrity upon transaction completion;

· independence- transactions initiated by different users, do not interfere in each other’s affairs;

· fault tolerance- after the transaction is completed, its results will no longer be lost.

The transaction mechanism supported by the database server is much more efficient than the similar mechanism in desktop DBMSs, because the server centrally controls the operation of transactions. In addition, in a file-server system, a failure on any of the workstations can lead to data loss and its inaccessibility to other workstations, while in a client-server system, a failure on the client almost never affects the integrity of the data and their availability to other clients.

Scalability

Scalability is the ability of the system to adapt to the growth in the number of users and the volume of the database with an adequate increase in the performance of the hardware platform, without replacing software.

It is well known that the capabilities of desktop DBMSs are seriously limited - five to seven users and 30-50 MB, respectively. The numbers, of course, represent some average values; in specific cases they can deviate in either direction. Most importantly, these barriers cannot be overcome by increasing hardware capabilities.

Systems based on database servers can support thousands of users and hundreds of GB of information - just give them the appropriate hardware platform.

Safety

The database server provides powerful means of protecting data from unauthorized access, which is not possible in desktop DBMSs. At the same time, access rights are administered very flexibly - down to the level of table fields. In addition, you can completely prohibit direct access to tables, allowing the user to interact with the data through intermediate objects - views and stored procedures. So the administrator can be sure that no too smart user will read what he is not supposed to read.

Flexibility

In a data application, there are three logical layers:

· user interface;

· logical processing rules(business rules);

· data management(just don’t confuse logical layers with physical levels, which will be discussed below).

As already mentioned, in a file server architecture, all three layers are implemented in one monolithic application running on a workstation. Therefore, changes in any of the layers clearly lead to modification of the application and subsequent updating of its versions on workstations.

In a two-tier client-server application shown in the figure above, as a rule, all functions for creating a user interface are implemented on the client, all functions for data management are implemented on the server, but business rules can be implemented both on the server using server programming mechanisms (stored procedures, triggers, views, etc.) and on the client.

In a three-tier application, there is a third, intermediate layer that implements business rules, which are the most frequently changed components of the application ( see fig. Three-tier client-server application model)

Rice. Three-tier client-server application model

The presence of not one, but several levels allows flexibility and minimal costs adapt the application to changing business requirements.

Let's try to illustrate all of the above with a small example. Let's assume that a certain organization's payroll rules (business rules) have changed and the corresponding software needs to be updated.

1) In a file server system, we "simply" make changes to the application and update its versions on workstations. But this “simply” entails maximum labor costs.

2) In a two-tier client-server system, if the payroll algorithm is implemented on the server in the form of a payroll rule, it is executed by a business rules server, implemented, for example, as an OLE server, and we will update one of its objects without changing anything neither in the client application nor on the database server.

3. Classification of standard servers

Typically, each server serves one (or several similar) protocols, and servers can be classified by the type of service they provide.

Universal servers are a special type server program, which does not provide any services independently. Instead, universal servers provide service servers with a simplified interface to interprocess communication resources and/or unified client access to various services. There are several types of such servers:

· inetd from English. internet super-server daemon demon IP services - a standard tool on UNIX systems - a program that allows you to write TCP/IP servers (and network protocols other families) working with the client through standard input and output streams redirected by inetd (stdin and stdout).

· RPC from English. Remote Procedure Call remote procedure call - a system for integrating servers in the form of procedures available for calling by remote user through unified interface. The interface, invented by Sun Microsystems for its operating system (SunOS, Solaris; Unix system), is currently used in both most Unix systems and Windows.

· Application client-server technologies Windows:

o (D-)COM (English (Distributed) Component Object Model - model of composite objects), etc. - Allows some programs to perform operations on data objects using the procedures of other programs. Initially, this technology is intended for their “implementation and linking of objects” (OLE English Object Linking and Embedding), but, in general, allows you to write a wide range of different application servers. COM only works within one computer; DCOM is accessible remotely via RPC.

o Active-X -- COM and DCOM extension for creating multimedia applications.

Universal servers are often used to write all kinds of information servers, servers that do not need any specific work with the network, servers that do not have any tasks other than serving clients. For example, ordinary console programs and scripts can act as servers for inetd.

Most internal and network specific Windows servers work through universal servers (RPC, (D-)COM).

Network services enable the functioning of the network, e.g. DHCP servers and BOOTP provide initial initialization of servers and workstations, DNS provides translation of names into addresses and vice versa.

Tunneling servers (for example, various VPN servers) and proxy servers provide communication with a network that is not accessible by routing.

AAA and Radius servers provide the network single authentication, authorization and access logging.

Information services. Information services include the simplest servers that report information about the host (time, daytime, motd), users (finger, ident), and servers for monitoring, for example SNMP. Most information services operate through universal servers.

A special type of information service is time synchronization servers - NTP, in addition to informing the client about the exact time, the NTP server periodically polls several other servers to correct its own time. In addition to time correction, the speed of the system clock is analyzed and adjusted. Time correction is carried out by accelerating or slowing down the system clock (depending on the direction of correction) in order to avoid problems that may occur with a simple time change.

File servers are servers for providing access to files on a server disk. server client file application

First of all, these are on-demand file transfer servers, by FTP protocols, TFTP, SFTP and HTTP. HTTP protocol transmission oriented text files, but servers can also serve arbitrary data as requested files, for example, dynamically created web pages, pictures, music, etc.

Other servers allow you to mount server disk partitions into the client's disk space and fully work with files on them. Servers allow this NFS protocols and SMB. NFS and SMB servers operate via the RPC interface.

Disadvantages of the file server system:

* Very high load on the network, increased bandwidth requirements. In practice, this makes it almost impossible to work simultaneously large number users with large amounts of data.

* Data processing is carried out on the users’ computer. This entails increased requirements for hardware each user. The more users, the more money will have to be spent on equipping their computers.

* Locking data when editing by one user makes it impossible for other users to work with this data.

* Safety. To ensure the ability to work with such a system, you will need to give each user full access to an entire file in which it may only be interested in one field

Data access servers maintain the database and provide data upon requests. One of the most simple servers a similar type is LDAP (Lightweight Directory Access Protocol).

There is no single protocol for accessing database servers, but all database servers are united by the use of uniform rules for forming queries -- SQL language(English: Structured Query Language).

Messaging services allow the user to send and receive messages (usually text messages).

First of all, these are servers Email, working using the SMTP protocol. The SMTP server receives the message and delivers it to the user's local mailbox or to another SMTP server (destination or intermediate server). On multi-user computers, users work with mail directly on the terminal (or web interface). To work with mail on a personal computer, mail is retrieved from the mailbox through servers running using the POP3 or IMAP protocols.

To organize conferences, there are news servers running using the NNTP protocol.

To exchange messages in real time, there are chat servers; a standard chat server operates using the IRC protocol - distributed chat for the Internet. Exists a large number of other chat protocols, such as ICQ or Jabber.

Remote access servers

Remote access servers, through the appropriate client program, provide the user with console access to the remote system.

To provide access to command line telnet, RSH, SSH servers serve.

The graphical interface for Unix systems - X Window System, has a built-in remote access server, as it was originally developed with this capability. Sometimes the ability to remotely access the X-Window interface is incorrectly called “X-Server” (this is the term used in X-Window for the video driver).

Standard remote access server graphical interface Microsoft Windows is called a terminal server.

Some type of management (more precisely, monitoring and configuration) also provides SNMP protocol. Computer or hardware device To do this, you must have an SNMP server.

Game servers are used for simultaneous play by several users in a single gaming situation. Some games have a server in the main package and allow you to run it in non-dedicated mode (that is, they allow you to play on the machine on which the server is running).

Server solutions are operating systems and/or software packages optimized for a computer to perform server functions and/or containing a set of programs for implementing typical services.

An example of server solutions is Unix systems, originally designed to implement server infrastructure, or server modifications Microsoft platforms Windows.

It is also necessary to select packages of servers and related programs (for example, a web server/PHP/MySQL kit for quick hosting deployment) for installation under Windows (Unix is characterized by a modular or “batch” installation of each component, so such solutions are rare).

In integrated server solutions, the installation of all components is performed at once; all components are, to one degree or another, tightly integrated and pre-configured with each other. However, in this case, replacing one of the servers or secondary applications (if their capabilities do not meet the needs) may pose a problem.

Server solutions serve to simplify the organization of the basic IT infrastructure of companies, that is, to quickly build a full-fledged network in a company, including from scratch. Combining individual server applications into a solution means that the solution is designed to perform most common tasks; at the same time, the complexity of deployment and the total cost of ownership of an IT infrastructure built on such solutions are significantly reduced.

Proxy server (from the English proxy - “representative, authorized”) is a service in computer networks that allows clients to make indirect requests to others network services. First, the client connects to the proxy server and requests a resource (for example, e-mail) located on another server. Then the proxy server either connects to the specified server and obtains the resource from it, or returns the resource from its own cache (in cases where the proxy has its own cache). In some cases, the client request or server response may be modified by the proxy server for certain purposes. The proxy server also allows you to protect the client computer from certain network attacks.

Conclusion

Thus, any computer network is essentially a client-server network. A user who connects his computer to the Internet will be dealing with a client-server network, and even if the computer does not have access to the network, its software and itself are most likely organized according to the client-server scheme.