DB IN CLIENT-SERVER-ARCHITECTUUR

Lezing overzicht

1. Clients en servers lokale netwerken

2. Client-server-systeemarchitectuur

3. Werklastmodellen in client/server-architectuur

4. Niveaus en modellen van client-serverarchitectuur

T.Connolly. Database. Ontwerp, implementatie en ondersteuning. Theorie en praktijk.: Vert. van Engels – M.: Uitgeverij. Williams House, 2006. – 1440 p.

1 Clients en servers van lokale netwerken

Het wijdverbreide gebruik van lokale computernetwerken is gebaseerd op het bekende idee van het delen van bronnen. De ontwikkeling van dit idee leidt tot de functionele scheiding van netwerkcomponenten: werkstations en lokale netwerkservers. De lokale netwerkserver (server) levert bronnen (diensten) aan werkstations en/of andere servers. Werkstation (clients) - computers die toegang bieden tot netwerkbronnen die door de server worden geleverd.

Door de focus op de aanpak open systemen, is het juister om te praten over logische servers (dat wil zeggen een reeks bronnen en software die diensten via deze bronnen leveren). Voorbeelden van logische servers zijn:

· een bestandsserver die een gemeenschappelijke bestandsopslag onderhoudt voor alle werkstations en, in het geval van een verzoek, het volledige bestand of de volledige gegevens naar de aanvragende computer wordt gekopieerd;

· de applicatieserver voert de applicatieonderdelen van client-serverapplicaties uit en bevat ook gegevens die beschikbaar zijn voor clients;

2 Client-serversysteemarchitectuur

De basisprincipes van de client-server-systeemarchitectuur zijn als volgt: de IS is verdeeld in twee delen, die kunnen worden uitgevoerd in verschillende knooppunten van het netwerk: de client- en serverdelen.

De serverzijde draait op een gespecialiseerd hardwarecomplex, dat bestaat uit krachtige hardware, de benodigde set standaardsoftware, een databasebeheersysteem en een database.

Het applicatieprogramma of de eindgebruiker heeft interactie met kant van de cliënt een systeem dat in het eenvoudigste geval eenvoudigweg een over-netwerkinterface biedt. De clientzijde van de applicatie werkt op de werkplek van de gebruiker, wat in de overgrote meerderheid van de gevallen een personal computer is.

Het clientgedeelte van het systeem heeft, indien nodig, toegang tot het servergedeelte via het netwerk (lokaal of globaal). Tegelijkertijd wordt vanuit het oogpunt van de client en de server de interactie transparant uitgevoerd. Netwerkcomponent, omvat het implementeren van deze interactie het geheel van het noodzakelijke netwerk uitrusting, een reeks softwaretechnologieën die zorgen voor gegevensoverdracht tussen netwerkknooppunten, evenals de feitelijke interfacesoftwarelaag (protocol of protocollen) voor het uitwisselen van verzoeken en de resultaten van de uitvoering ervan. Als belangrijkste interface tussen de klant en serveronderdelen De databasetaal is SQL.

Meest makkelijke vorm Client-server-architecturen zijn de verdeling van de computerbelasting over twee afzonderlijke processen: de client en de server. Bovendien zijn er vijf groepen functies van een standaard interactieve applicatie verdeeld over deze twee processen:

1) dialoogfuncties (Presentatielogica, PL) of visualisatiecomponent. De appbiedt informatie-invoer door de gebruiker met behulp van bepaalde middelen, evenals het weergeven van informatie op het scherm en afdrukken. De visualisatiecomponent voor de client-serverarchitectuur wordt altijd uitgevoerd op de werkplek van de gebruiker (aangezien hij eventuele resultaten van het programma moet observeren). Om de presentatielogica te organiseren, wordt voornamelijk het grafische gebruikersinterfacemodel GUI (User Interface Graphical) of webinterface gebruikt;

2) applicatiefuncties of dit is onderdeel van de applicatiecode met gegevensverwerkingsalgoritmen (Business Logic, BL). De toegepaste logische component lost feitelijk een of ander probleem op dat verband houdt met gegevensverwerking in een of ander gebied en vertegenwoordigt algoritmen voor de reactie van de applicatie op gebruikersacties of interne gebeurtenissen, regels voor gegevensverwerking. Dit onderdeel kan worden gedistribueerd tussen de client- en serveronderdelen op verschillende manieren afhankelijk van het gebruikte model. Meestal wordt deze code geprogrammeerd in programmeertalen hoog niveau: C, C++, Visual Basic, Object Pascal, enz.;

3) gegevensverwerkingsfuncties binnen de applicatie (Database Logic, DL) - dit is het deel van de applicatiecode dat verband houdt met het ophalen en manipuleren van gegevens (het DBMS beheert de gegevens zelf). De subtaal is SQL.

Typische client-server-applicatiestructuur

4) controlefuncties informatiebronnen(Database Manager-systeem, DBMS). De databaseopslagcomponent voert fysieke bewerkingen uit die verband houden met het opslaan van gegevens, het lezen van informatie uit de database en het schrijven ernaar, gerelateerd aan de applicatietaak die door de applicatie wordt opgelost. In een client-server-architectuur draait dit onderdeel altijd op de server;

5) servicefuncties die de rol spelen van verbindingen tussen eerdere groepen functies.

3 Werklastmodellen in client/server-architectuur

"Client-server"-systemen kunnen vertrouwen op verschillende soorten verantwoordelijkhedenverdeling tussen de client en de server:

· “intelligente” clients (thick client - thin server);

· “intelligente” server (thin client - dikke server);

· gemengde systemen;

· systemen met meerdere niveaus.

DIV_ADBLOCK80">

"Intelligente" servers. Door alle bedrijfsregels over te brengen naar SQL Server, waar ze worden geïmplementeerd in de vorm van opgeslagen procedures en databasetriggers, ontstaat een ‘intelligente’ server; de server is ook verantwoordelijk voor het opslaan en exploiteren van de database. De intelligentie van de server komt ook tot uiting in de mogelijkheid om data te manipuleren (SQL-query's uit te voeren) en de resulterende dataset terug te sturen naar de client.

Alleen de logica voor gegevenspresentatie is geïmplementeerd op de clientcomputer.

Voordelen:

· het verhogen van de prestaties van het informatiesysteem: bedrijfslogica draait in dezelfde adresruimte als de toegangscode voor de database, en is bovendien nauw geïntegreerd met het gegevenszoekmechanisme. Dit betekent dat gegevens niet vóór verwerking hoeven te worden verplaatst of gekopieerd netwerk verkeer geminimaliseerd;

· het is gemakkelijker om de gegevensintegriteit op de server te garanderen;

· indien nodig wordt de bedrijfslogica centraal aangepast, zonder dat er van klant gewisseld wordt.

Gebreken:

· toenemende eisen aan serverbronnen, waar alle verzoeken en gegevensmanipulaties worden uitgevoerd.

Gemengde systemen. Ook gemengde opties zijn mogelijk, met de voordelen van zowel intelligente servers als intelligente clients. Een DBMS, logica voor gegevensmanipulatie en dat deel van de bedrijfslogica dat bij veel clients gebruikelijk is, worden meestal op de server geïmplementeerd. De datapresentatielogica en een deel van de bedrijfslogica die specifiek is voor deze klant, worden op de klant ingezet.

Voordelen van gemengde systemen:

· servercode is voor veel clients tegelijkertijd beschikbaar, waardoor de overhead bij het uitvoeren van soortgelijke verzoeken wordt verminderd;

· clientprestaties zijn minder afhankelijk van netwerkverkeer.

Gebreken:

· bedrijfslogica wordt verdeeld tussen de client en de server, en bij het moderniseren van de applicatie is het noodzakelijk om nieuwe versies van het clientgedeelte onder een breed publiek te verspreiden.

Systeem met meerdere niveaus(soms drie niveaus genoemd) stelt u in staat te scheiden gebruikersomgeving, bedrijfsregels en database. In een systeem met meerdere lagen worden bedrijfsregels op de applicatieserver geplaatst softwarecomponent, die tussen de databaseserver en clients wordt geplaatst. De client is alleen verantwoordelijk voor de gebruikersinterface, de databaseserver is verantwoordelijk voor het onderhoud en de werking van de database zelf. De middleware is een server voor de gebruiker en een client voor het databasebeheersysteem. Clients wenden zich indien nodig tot de applicatieserver, die zich op zijn beurt tot de databaseserver wendt voor de gegevens die nodig zijn om clientverzoeken te implementeren.

Voordelen van systemen met meerdere niveaus:

· scheiding van interfacecomponenten, bedrijfsregels en gegevensopslag, waardoor de prestaties van de databaseserver en de bescherming ervan tegen ongeoorloofde toegang toenemen;

· gecentraliseerde wijziging van bedrijfsregels;

Gebreken:

· het netwerkverkeer neemt toe.

· dergelijke systemen zijn veel moeilijker te ontwikkelen, te implementeren en te exploiteren en vereisen aanzienlijke kosten en hooggekwalificeerd personeel.

4 niveaus en modellen van architectuur"client server"

Qua hoeveelheid componenten client-serversystemen zijn onderverdeeld in twee-niveaus en drie-niveaus.

Systemen met twee niveaus bestaan ​​uitsluitend uit een client en een server. Client-server-architectuurmodellen met twee niveaus omvatten:

1) bestandsservermodel (FS-model);

2) model voor toegang op afstand (RDA-model);

3) actief servermodel (DBS-model).

Het drielagenmodel wordt weergegeven door een type client-serverarchitectuur gebaseerd op het client-applicatieserverschema. Deze architectuur maakt een flexibelere distributie van systeemfuncties en belasting tussen componenten van het hardware- en softwarecomplex mogelijk, en kan ook de resourcevereisten voor gebruikerswerkstations verminderen.

Bestandsserverarchitectuur

In de “file server”-architectuur (File Server, FS-model) bevinden alle hoofdfuncties van de informatiesysteemapplicatie (presentatielogica, bedrijfslogica en gegevensverwerkings- en beheerfuncties) zich op de client (Fig. 2).

De server bevat gegevensbestanden en ondersteunt toegang tot de bestanden.

In dit model neemt de client contact op met de server met een verzoek om gegevens. Het verzoek van de klant wordt geformuleerd in NMD-opdrachten. Het DBMS vertaalt dit verzoek in een reeks bestandsopdrachten, het File Management System (FMS) leest de opgevraagde gegevens uit de database en draagt ​​deze gegevens blok voor blok over aan de clientapplicatie, vervolgens analyseert de DBMS-client de ontvangen informatie en als de ontvangen blok geen antwoord op het verzoek bevat, dan wordt er een beslissing genomen over het pompen van het volgende blok met informatie, enz. In feite gaat het FS-model ervan uit autonome werking IP-software ingeschakeld verschillende auto's online. IS-componenten interageren alleen vanwege de aanwezigheid gedeelde opslag gegevens. Natuurlijk moet een dergelijke opslag een goed ontworpen database zijn die wordt beheerd door een DBMS dat het FS-model ondersteunt, bijvoorbeeld de Informix SE DBMS. Dit soort DBMS kan niet als een “echte server” worden beschouwd.

Architectuurmodel voor bestandsservers

Bij gebruik van het FS-model wordt voor elke door de gebruiker geïnitieerde sessie met het DBMS een kopie van het DBMS gemaakt, die op dezelfde processor draait als het gebruikersproces.

Over het algemeen hebben we in de IS-architectuur voor bestandsservers een “dikke” client en een zeer “dunne” server, in de zin dat bijna al het werk aan de clientzijde wordt gedaan, en de server alleen voldoende schijfgeheugencapaciteit nodig heeft.

De nadelen van de bestandsserverarchitectuur zijn onder meer:

· veel netwerkverkeer, dat gepaard gaat met de overdracht via het netwerk van veel blokken en bestanden die vereist zijn voor clienttoepassingen;

· een beperkt aantal commando's voor gegevensmanipulatie; in feite zijn dit alleen bestandscommando's;

· lage prestaties (afhankelijk van de prestaties van het netwerk, server, client);

· slecht vermogen om nieuwe klanten aan te sluiten;

· gebrek aan ontwikkelde tools voor gegevensbescherming (alleen op bestandssysteemniveau).

De onbetwiste voordelen omvatten

· hoge efficiëntie van het werken met kleine volumes gegevens in de modus voor één gebruiker.

· gemak van gecentraliseerde toegangscontrole;

· goedkoop ontwikkeling;

· hoge snelheid ontwikkeling;

· Niet hoge prijs software-updates en -wijzigingen.

Het FS-model komt niet overeen met moderne ideeën over client-server-technologie in de algemeen aanvaarde zin. Daarom wordt deze methode voor het organiseren van gedistribueerd computergebruik beschouwd als een afzonderlijke bestandsserverarchitectuur.

Model voor toegang op afstand naar de gegevens ADH ( Op afstand Gegevens Toegang , ADH )

Historisch gezien was dit model het allereerste dat werd ontwikkeld. In dit model slaat het servergedeelte alleen gegevens op, bevindt de DBMS-kern zich hier ook en is de logica voor gegevensmanipulatie geïmplementeerd, en implementeert het clientgedeelte alle applicatielogica. In dit geval stuurt de client verzoeken naar de server om gegevens te verkrijgen, en de server stuurt bepaalde monsters terug naar de client. Het meest gebruikelijke communicatiemiddel tussen client en server is in dit geval SQL ( gestructureerde taal queries) is een standaard niet-procedurele taal gericht op gegevensverwerking.

De client is merkbaar afgevallen in vergelijking met het FS-model, maar de serverfuncties zijn aanzienlijk uitgebreid, het netwerkverkeer is afgenomen en het belangrijkste voordeel van het RDA-model: de SQL-taal is verschenen met een uitgebreide set gegevensdefinitie en gegevensmanipulatie commando's, die de client-serverinterface verenigden.

Architectuurmodel voor externe gegevenstoegang

Voordelen van het RDA-model:

· het overbrengen van Business Logic naar de client ontlast de databaseserver aanzienlijk, waardoor het totale aantal processen in het besturingssysteem wordt geminimaliseerd;

· de databaseserver wordt bevrijd van voor hem ongebruikelijke functies, waardoor de processor volledig kan worden geladen met bewerkingen voor het verwerken van queries, gegevens en transacties;

· de netwerkbelasting wordt sterk verminderd, omdat er geen verzoeken om invoer/uitvoer in bestandsterminologie van clients naar de server worden verzonden, maar verzoeken om SQL, en hun volume is aanzienlijk kleiner. Naar aanleiding van verzoeken ontvangt de klant uitsluitend gegevens relevant voor het verzoek, en geen blokken bestanden, zoals in het FS-model.

Nadelen van het RDA-model:

· het netwerkverkeer is nog steeds hoog, vooral wanneer grote hoeveelheden klanten en hun intensief werk interactief;

· buitensporige duplicatie van applicatiecode, bijvoorbeeld het herhalen van bedrijfslogica voor elke klant;

· toenemende complexiteit van clientapplicaties in termen van controle over informatiebronnen. De server speelt een passieve rol. Als we bijvoorbeeld de veiligheidsvoorraden van goederen in een magazijn moeten monitoren, dan zal elke toepassing die verband houdt met een verandering in de toestand van het magazijn, na het uitvoeren van gegevenswijzigingsbewerkingen die de verkoop of verwijdering van goederen uit het magazijn simuleren, moet een controle uitvoeren op de omvang van het saldo en, als dit kleiner is dan de veiligheidsvoorraad, een overeenkomstig verzoek indienen voor de levering van de benodigde goederen. Dit bemoeilijkt de clienttoepassing

Databaseservermodel (ook wel actieve server genoemd)

Servermodel (Data Base Server, DBS) is een concept waarbij de applicatiecomponent (bedrijfslogica) zich gedeeltelijk of volledig op de databaseserver bevindt (Fig. 4). Bedrijfslogica wordt geïmplementeerd in de vorm van opgeslagen programma-eenheden (SPU), triggers en aangepaste gegevenstypen, die in de database worden opgeslagen en door de server worden beheerd. De database verzamelt ook gegevens en vormt een metadatadatabase (MDB). De clientapplicatie neemt contact op met de server met het commando om PrE te starten, en de server voert dit indien nodig uit en legt de wijzigingen vast in de database. De server stuurt het resultaat van het verzoek terug naar de client, hetzij voor uitvoer naar een randapparaat, hetzij voor het uitvoeren van een deel van de bedrijfslogica die zich op de client bevindt. Met deze manier van dataverwerking wordt het netwerkverkeer sterk verminderd.

Een trigger is een mechanisme voor het volgen van speciale gebeurtenissen die verband houden met de status van de database. Een trigger in een database is als een tuimelschakelaar die wordt geactiveerd wanneer een bepaalde gebeurtenis in de database plaatsvindt. De DBMS-kernel bewaakt alle gebeurtenissen die gecreëerde en beschreven triggers in de database veroorzaken, en wanneer een overeenkomstige gebeurtenis optreedt, lanceert de server de bijbehorende trigger => een trigger is een programma dat in de database draait en opgeslagen procedures aanroept.

Dit servermodel is actief omdat niet alleen de client, maar ook de server zelf gebruik maakt van het triggermechanisme.
Voordelen:

Het DBS-model wordt door de meeste ondersteund moderne DBMS: Oracle, Sybase, Ingres, Informix, MS SQL Server, hoewel functionaliteit ze hebben verschillende.

Voordelen van het DBS-model:

· mogelijkheid tot gecentraliseerd beheer van applicatiefuncties;

· vermindering van het netwerkverkeer dankzij de mogelijkheden voor procedureoproepen op afstand;

· de mogelijkheid om procedures door verschillende applicaties te scheiden en computerbronnen te besparen door gebruik te maken van een eenmaal gemaakt SQL-query-uitvoeringsplan. (aangezien opgeslagen procedures en triggers worden opgeslagen in het databasewoordenboek en door meerdere clients kunnen worden gebruikt => duplicatie van algoritmen voor gegevensverwerking in verschillende clienttoepassingen wordt verminderd).

Gebreken:

Serverfuncties:

1. Bewaakt gebeurtenissen die verband houden met de beschreven triggers;

2. Biedt automatische activering van triggers wanneer gerelateerde gebeurtenissen plaatsvinden;

3. Zorgt voor de uitvoering van het interne programma van elke trigger;

4. Voert opgeslagen procedures uit op basis van gebruikersverzoeken;

5. Start opgeslagen procedures vanaf triggers;

6. Geeft de benodigde gegevens terug aan de opdrachtgever;

7. Biedt alle functies van het DBMS: toegang tot gegevens, controle en onderhoud van de gegevensintegriteit in de database, toegangscontrole, zorgen voor een correcte werking van alle gebruikers met één enkele database.

De server voert inderdaad een groot aantal functies uit en bedient veel clients. Om de server te ontlasten zijn modellen met meerdere niveaus en vooral een model met drie niveaus ontwikkeld.

Applicatieserver

Applicatieserver (Sollicitatie server, ALS) - een type client-server-architectuur met meerdere niveaus, gebaseerd op het client-applicatieserver-schema.

Dit model introduceert een extra tussenlaag tussen de client en de server. Deze middelste laag bevat een of meer applicatieservers. Vandaar de identieke naam - "applicatieservermodel" AS (Applicatieserver).

In dit model zijn alle IS-componenten verdeeld over drie performers.

De client implementeert de gebruikersinterface, levert de presentatielogica van de applicatie, start de gelokaliseerde klantmachine clienttoepassingscode die communicatiefuncties uitvoert voor toegang tot lokale of globaal netwerk, autorisatie-interface, encryptie-algoritmen, controle van invoerwaarden op geldigheid en naleving van het formaat, eenvoudige handelingen (sorteren, groeperen, tellen van waarden) met gegevens die al zijn geladen op de interface (meestal grafische) component, dat wil zeggen de applicatie zelf voor de eindgebruiker. De client en applicatieserver communiceren met behulp van API's, en de applicatieserver en databaseserver communiceren met behulp van de SQL-querytaal.

Applicatieservermodel

Applicatieservers voeren de meest voorkomende bedrijfsregels uit, ondersteunen de domeinomgeving en zorgen voor de uitwisseling van berichten tussen applicatiecomponenten. Applicatiefuncties van de applicatieserver zijn ontworpen als afzonderlijke services of services (Service). De dienst biedt een aantal diensten aan alle programma's die deze willen en kunnen gebruiken. In een IS-architectuur kunnen er meerdere applicatieservers zijn, en elk daarvan levert een specifieke set services. Elk programma dat hiervan gebruik maakt, wordt beschouwd als een AC-toepassingsserverclient (Application Client). De implementatiedetails van applicatiefuncties op de applicatieserver zijn volledig verborgen voor de applicatieclient. De AS doet een verzoek aan een specifieke dienst, en niet aan de AS. Verzoeken worden in de wachtrij geplaatst bij een AS-proces, dat ze doorgeeft aan een specifieke dienst voor verwerking volgens vastgestelde prioriteiten.

Databaseservers in dit model houden zich uitsluitend bezig met DBMS-functies.

In de eenvoudigste configuratie kan de applicatieserver fysiek gecombineerd worden met een databaseserver op één computer, waarop één of meerdere clients via het netwerk verbinding maken.

In de “juiste” (vanuit het oogpunt van veiligheid, betrouwbaarheid, schaalbaarheid) configuratie bevindt de databaseserver zich op een speciale computer (of cluster), waarmee een of meer applicatieservers via het netwerk zijn verbonden, waarmee, op hun beurt zijn klanten via het netwerk verbonden.

Voordelen van het AS-model:

· verhoogde productiviteit door de server te ontlasten;

Het verlagen van de exploitatiekosten van het IP;

· het vermogen om bedrijfslogica te compliceren zonder prestatieverlies;

· het verbeteren van de draagbaarheid en schaalbaarheidseigenschappen van de IS door het gebruik ervan standaard talen programmeren, bijvoorbeeld C, C++, Borland Pascal, Small Talk, Java, om de meeste bedrijfslogica te implementeren.

· clientsoftware vereist geen beheer;

· configureerbaarheid – door de niveaus van elkaar te isoleren, kunt u het systeem snel en eenvoudig opnieuw configureren wanneer er fouten optreden of wanneer gepland onderhoud op een van de niveaus;

· hoge beveiliging;

· hoge betrouwbaarheid;

· lage vereisten voor kanaal(netwerk)snelheid tussen clients en applicatieserver;

lage prestatie-eisen en technische specificaties klanten, waardoor hun waarde afneemt.

Gebreken:

· de complexiteit van het servergedeelte en als gevolg daarvan de kosten voor beheer en onderhoud groeien;

· hogere complexiteit bij het maken van applicaties;

· moeilijker in te zetten en te beheren;

· hoge eisen aan de prestaties van applicatieservers en databaseservers, en dus aan de hoge kosten serverapparatuur;

· hoge eisen aan kanaal(netwerk)snelheid tussen de databaseserver en applicatieservers.

De momenteel populaire architectuur van websystemen kan worden weergegeven in een versie met drie niveaus.

In de regel zijn computers en programma's die deel uitmaken van een informatiesysteem niet gelijk. Sommigen van hen bezitten bronnen (bestandssysteem, processor, printer, database, etc.), anderen hebben toegang tot deze bronnen. De computer (of het programma) die een bron beheert, wordt de server van die bron genoemd (bestandsserver, databaseserver, computerserver...). De client en server van elke bron kunnen zich op dezelfde computer of op dezelfde computer bevinden diverse computers verbonden door een netwerk.

Binnen het raamwerk van een representatie op meerdere niveaus van computersystemen kunnen drie groepen functies worden onderscheiden, gericht op het oplossen van verschillende deeltaken:

1. gegevensinvoer en weergavefuncties (bieden gebruikersinteractie);
2. toegepaste functies specifiek voor een bepaald vakgebied;
3. functies voor resourcebeheer ( bestandssysteem, databank, enz.)

Figuur 1. Componenten van netwerkapplicaties

De implementatie van deze functies wordt voornamelijk verzorgd door software, die kan worden weergegeven in de vorm van onderling verbonden componenten (), waarbij:

• onderdeel bekijken verantwoordelijk voor de gebruikersinterface;
• applicatiecomponent implementeert een algoritme voor het oplossen van een specifiek probleem;
• controlecomponent hulpbron biedt toegang tot de noodzakelijke hulpbronnen.

Een zelfstandig systeem (een computer die niet is aangesloten op een netwerk) vertegenwoordigt al deze componenten, zowel op verschillende niveaus (OS, hulpprogramma's en hulpprogramma's, applicatiesoftware) als op applicatieniveau (niet typisch voor moderne programma's). Het netwerk is hetzelfde: het vertegenwoordigt al deze componenten, maar is over het algemeen verdeeld over knooppunten. De taak komt neer op het waarborgen netwerken tussen deze componenten.

Client-server-architectuur definieert algemene principes het organiseren van interactie in een netwerk waar die er zijn servers, knooppunten die een aantal specifieke functies (diensten) bieden en klanten, consumenten van deze functies.

Praktische implementaties van een dergelijke architectuur worden genoemd client-server-technologieën. Elke technologie definieert zijn eigen regels of gebruikt bestaande regels voor de interactie tussen client en server, die worden genoemd uitwisselingsprotocol (interactieprotocol).

In elk netwerk (zelfs peer-to-peer), gebouwd op moderne netwerktechnologieën, zijn er elementen client-server-interactie, meestal gebaseerd op architectuur met twee lagen. Het wordt two-tier (two-tier, 2-tier) genoemd vanwege de behoefte aan distributie drie eenvoudig componenten tussen twee knooppunten(client en server).

Fig. 2. Client-server-architectuur met twee lagen

In client-serversystemen wordt een tweelaagse architectuur gebruikt, waarbij de server direct en volledig reageert op clientverzoeken, waarbij alleen gebruik wordt gemaakt van zijn eigen bronnen. Die. de server roept geen netwerkapplicaties van derden op en heeft geen toegang bronnen van derden om een ​​deel van het verzoek uit te voeren ()

De locatie van componenten aan de client- of serverzijde bepaalt de volgende basismodellen van hun interactie binnen een architectuur met twee lagen:

• terminal-server— gedistribueerde gegevenspresentatie;
• bestanden server— toegang tot een database op afstand en bestandsbronnen;
• database server— presentatie van gegevens op afstand;
• applicatieserver- applicatie op afstand.

De vermelde modellen met variaties worden gepresenteerd op.

Afb.3. Client-server-interactiemodellen

Historisch gezien was het model van gedistribueerde gegevenspresentatie (terminalservermodel) het eerste dat verscheen. Het werd geïmplementeerd op een universele computer (mainframe), die als server fungeerde, met alfanumerieke terminals erop aangesloten. Gebruikers voerden gegevens in vanaf het terminaltoetsenbord, die vervolgens naar het mainframe werden overgebracht en daar werden verwerkt, inclusief de vorming van een “beeld” van de resultaten. Deze “afbeelding” werd op het terminalscherm teruggestuurd naar de gebruiker.

Met de komst van personal computers en lokale netwerken werd een bestandsservermodel geïmplementeerd dat toegang bood tot bestandsbronnen, waaronder een database op afstand. In dit geval is de specifieke netwerkhost een bestandsserver waarop databasebestanden zich bevinden. Clients voeren applicaties uit die een presentatiecomponent en een applicatiecomponent (DBMS en applicatieprogramma) combineren, waarbij de aangesloten externe database als lokaal bestand wordt gebruikt. In dit geval vertegenwoordigen uitwisselingsprotocollen een reeks oproepen op laag niveau naar bestandssysteembewerkingen.

Dit model is ineffectief gebleken vanwege het feit dat er problemen optreden bij het actief werken met databasetabellen. enorme druk naar het netwerk. Een gedeeltelijke oplossing is het ondersteunen van de replicatie van tabellen en query's. In dit geval wordt bijvoorbeeld, wanneer gegevens veranderen, niet de hele tabel bijgewerkt, maar alleen het gewijzigde deel ervan.

Met de komst van gespecialiseerde DBMS'en werd het mogelijk om een ​​ander model van toegang tot een database op afstand te implementeren: het databaseservermodel. In dit geval werkt de DBMS-kernel op de server, applicatieprogramma op de client en het communicatieprotocol wordt geleverd met behulp van de SQL-taal. Deze aanpak leidt, vergeleken met een bestandsserver, tot een vermindering van de netwerkbelasting en tot unificatie van de client-serverinterface. Het netwerkverkeer blijft echter vrij hoog en het is nog steeds onmogelijk om applicaties op bevredigende wijze te beheren, omdat verschillende functies in één programma worden gecombineerd.

Met de ontwikkeling en implementatie van het opgeslagen proceduremechanisme op databaseserverniveau is het concept van actieve databaseserver. In dit geval worden sommige functies van de applicatiecomponent geïmplementeerd in de vorm van opgeslagen procedures die aan de serverzijde worden uitgevoerd. De rest van de applicatielogica wordt aan de clientzijde uitgevoerd. Het interactieprotocol is het overeenkomstige dialect van de SQL-taal.

De voordelen van deze aanpak liggen voor de hand:

• gecentraliseerd beheer van applicatiefuncties is mogelijk;
• het verlagen van de kosten van systeemeigendom (TOC, totale eigendomskosten) door een server te huren in plaats van deze te kopen;
• aanzienlijke vermindering van het netwerkverkeer (aangezien het geen SQL-query's zijn die worden verzonden, maar oproepen naar opgeslagen procedures).

Het grootste nadeel zijn de beperkte tools voor het ontwikkelen van opgeslagen procedures in vergelijking met talen op hoog niveau.

De implementatie van een applicatiecomponent aan de serverzijde vertegenwoordigt het volgende model: een applicatieserver. Het verplaatsen van de functionaliteit van applicatiecomponenten naar de server vermindert de vereisten voor clientconfiguratie en vereenvoudigt het beheer, maar stelt hogere eisen aan de prestaties, beveiliging en betrouwbaarheid van de server.

Momenteel is er een tendens om terug te keren naar waar de client-server-architectuur begon: het centraliseren van computergebruik op basis van het terminal-server-model. In de moderne reïncarnatie verschillen terminals van hun alfanumerieke voorouders doordat ze, met een minimum aan software en hardware, vertegenwoordigen multimediamogelijkheden(incl. grafische gebruikersinterface). De werking van de terminals wordt verzekerd door een krachtige server, waarop alles zich bevindt, inclusief stuurprogramma's voor virtuele apparaten, inclusief stuurprogramma's voor videosubsystemen.

Afb.4. Client-server-architectuur met drie lagen

Een andere trend in client-server-technologieën is het toenemende gebruik van gedistribueerd computergebruik. Ze worden geïmplementeerd op basis van het applicatieservermodel, waarbij de netwerkapplicatie in twee of meer delen is verdeeld, die elk kunnen worden uitgevoerd op aparte computer. Speciale delen van de applicatie communiceren met elkaar en wisselen berichten uit in een vooraf afgesproken formaat. In dit geval ontstaat er een tweeledige client-server-architectuur drielaags (drielaags, drielaags).

In de regel is de derde schakel in een architectuur met drie niveaus de applicatieserver, d.w.z. componenten zijn als volgt verdeeld ():

1. De gegevenspresentatie vindt plaats aan de klantzijde.
2. Applicatiecomponent - op een speciale applicatieserver (optioneel, het uitvoeren van de functies van middleware).
3. Resourcebeheer - op de databaseserver, die de gevraagde gegevens levert.

Afb.5. Multi-tier (N-tier) client-server-architectuur

De drielaagse architectuur kan worden uitgebreid meerlaags (N-laag, meerlaags) door extra servers toe te wijzen, die elk hun eigen diensten zullen leveren en de diensten van andere servers zullen gebruiken verschillende niveaus. Een abstract voorbeeld van een multi-linkmodel wordt gegeven op.

Vergelijking van architecturen

De two-tier architectuur is eenvoudiger, omdat alle verzoeken door één server worden afgehandeld, maar is juist daardoor minder betrouwbaar en stelt hogere eisen aan de serverprestaties.

De architectuur met drie niveaus is complexer, maar vanwege het feit dat functies worden verdeeld tussen de servers op het tweede en derde niveau, vertegenwoordigt deze architectuur:

1. Hoge mate van flexibiliteit en schaalbaarheid.
2. Hoge beveiliging(omdat bescherming per service of niveau kan worden gedefinieerd).
3. Hoge performantie(aangezien taken over servers worden verdeeld).

Client-server-technologieën

Er wordt gebruik gemaakt van client-server-architectuur groot nummer netwerktechnologieën die worden gebruikt om toegang te krijgen tot verschillende netwerkdiensten. Laten we kort kijken naar enkele soorten van dergelijke services (en servers).

Webservers Aanvankelijk boden ze toegang tot hypertekstdocumenten via HTTP-protocol(Hupper-tekstoverdrachtprotocol). Nu ondersteunen ze geavanceerde mogelijkheden, in het bijzonder werken ze ermee binaire bestanden(afbeeldingen, multimedia, enz.). Applicatieservers Ontworpen voor een gecentraliseerde oplossing van toegepaste problemen in een bepaald vakgebied. Om dit te doen, hebben gebruikers het recht launch serverprogramma's voor executie. Het gebruik van applicatieservers vermindert de vereisten voor clientconfiguratie en vereenvoudigt het algehele netwerkbeheer. Databaseservers Databaseservers worden gebruikt om gebruikersverzoeken te verwerken SQL-taal. In dit geval bevindt het DBMS zich op de server waarmee clienttoepassingen verbinding maken. Bestandsservers Bestanden server winkels informatie in de vorm van bestanden en geeft gebruikers hier toegang toe. In de regel biedt een bestandsserver ook een bepaald niveau van bescherming tegen ongeautoriseerde toegang. Proxy server Ten eerste fungeert het als tussenpersoon en helpt het gebruikers informatie van internet te verkrijgen terwijl het netwerk wordt beschermd. Ten tweede slaat het veelgebruikte informatie op in het cachegeheugen lokale schijf, waardoor het snel aan gebruikers wordt geleverd zonder opnieuw toegang tot internet te hoeven hebben. Firewalls(firewalls) Firewalls, het analyseren en filteren van passerend netwerkverkeer om de netwerkbeveiliging te garanderen. Mailservers Diensten verlenen voor het verzenden en ontvangen van elektronische postberichten. Remote Access Servers (RAS) Deze systemen bieden connectiviteit met het netwerk via inbellijnen. Medewerker op afstand kan de bronnen van een bedrijfs-LAN gebruiken door er verbinding mee te maken via een gewone modem.

Dit zijn slechts enkele typen van de hele verscheidenheid aan client-servertechnologieën die in zowel lokale als mondiale netwerken worden gebruikt.

Om toegang te krijgen tot bepaalde netwerkdiensten worden clients gebruikt waarvan de mogelijkheden worden gekenmerkt door het concept van “dikte”. Het definieert de hardwareconfiguratie en software die beschikbaar zijn voor de client. Laten we mogelijke grenswaarden bekijken:

“Thin” client Deze term definieert een client wiens computerbronnen alleen voldoende zijn om de benodigde netwerkapplicatie via een webinterface uit te voeren. De gebruikersinterface van een dergelijke applicatie wordt gevormd door middelen statisch HTML (JavaScript-uitvoering is niet beschikbaar), alle applicatielogica wordt uitgevoerd op de server.
Om de thin client te laten werken, volstaat het om de mogelijkheid te bieden een webbrowser te starten, in het venster waarvan alle acties worden uitgevoerd. Om deze reden wordt een webbrowser vaak een "universele client" genoemd. “Thick” client Dit is een werkstation of personal computer met een eigen schijf. besturingssysteem en hebben noodzakelijke set software. NAAR netwerkservers“dikke” klanten komen er vooral voor aanvullende diensten(bijvoorbeeld toegang tot een webserver of bedrijfsdatabase).
Een “dikke” client betekent ook een clientnetwerktoepassing die onder het lokale besturingssysteem draait. Een dergelijke applicatie combineert een datapresentatiecomponent (grafische gebruikersinterface van het besturingssysteem) en een applicatiecomponent (de rekenkracht van de clientcomputer).

IN De laatste tijd Er wordt steeds vaker een andere term gebruikt: ‘rijke’ cliënt. De “rijke” klant is een soort compromis tussen de “dikke” en “dunne” klanten. Net als de thin client vertegenwoordigt ook de rijke client GUI, al beschreven met behulp van XML en inclusief een aantal rijke clientfunctionaliteiten (bijvoorbeeld een drag-and-drop-interface, tabbladen, meerdere vensters, vervolgkeuzemenu's, enz.)

De applicatielogica van de “rijke” client is ook op de server geïmplementeerd. Gegevens worden verzonden naar standaard formaat uitwisseling, gebaseerd op dezelfde XML ( SOAP-protocollen, XML-RPC) en worden door de klant geïnterpreteerd.

Hieronder vindt u enkele basis-XML-gebaseerde rich client-protocollen:

• XAML (eXtensible Application Markup Language) - ontwikkeld door Microsoft, gebruikt in applicaties op het .NET-platform;
• XUL (XML User Interface Language) is een standaard die daarin is ontwikkeld Mozilla-project, bijvoorbeeld gebruikt in e-mailclient Mozilla Thunderbird of Mozilla Firefox-browser;
• Flex- multimedia-technologie op XML-gebaseerd, ontwikkeld door Macromedia/Adobe.

Conclusie

Dus, Het hoofdidee van de client-serverarchitectuur is om de netwerkapplicatie in verschillende componenten te verdelen, die elk een specifieke reeks services implementeren. De componenten van zo’n applicatie kunnen draaien verschillende computers, het uitvoeren van server- en/of clientfuncties. Dit verbetert de betrouwbaarheid, veiligheid en prestaties netwerktoepassingen en het netwerk in het algemeen.

Controle vragen

1. Wat is het belangrijkste K-S idee interacties?
2. Wat is het verschil tussen de concepten ‘client-serverarchitectuur’ en ‘client-servertechnologie’?
3. Noem de componenten van C-S-interactie.
4. Welke taken voert de presentatiecomponent uit in de KS-architectuur?
5. Met welk doel worden tools voor databasetoegang gepresenteerd als een afzonderlijk onderdeel in de KS-architectuur?
6. Waarom wordt bedrijfslogica benadrukt als een afzonderlijk onderdeel in de KS-architectuur?
7. Noem de modellen van client-server-interactie.
8. Beschrijf het bestandsservermodel.
9. Beschrijf het databaseservermodel.
10. Beschrijf het "applicatieserver"-model
11. Beschrijf het terminalservermodel
12. Noem de belangrijkste typen servers.

Vast adres van deze pagina:

Om deze problemen op te lossen, worden client-server-architecturen met meerdere niveaus (drie of meer niveaus) gebruikt.

Dergelijke architecturen distribueren op intelligentere wijze de gegevensverwerkingsmodules zaak wordt uitgevoerd op een of meer aparte servers. Deze softwaremodules voer de functies uit van een server voor interfaces met gebruikers en een client voor databaseservers. Bovendien kunnen verschillende applicatieservers met elkaar communiceren om het systeem nauwkeuriger te verdelen in functionele eenheden die specifieke rollen vervullen.

U kunt bijvoorbeeld een personeelsbeheerserver selecteren die alle functies uitvoert die nodig zijn voor personeelsbeheer. Door er een aparte database aan te koppelen, kunt u alle implementatiedetails van deze server voor gebruikers verbergen, waardoor ze alleen toegang hebben tot de openbare functies. Bovendien is zo'n systeem heel gemakkelijk aan te passen aan het web, omdat het gemakkelijker is om HTML-formulieren te ontwikkelen waarmee gebruikers toegang kunnen krijgen tot bepaalde functies van de database dan tot alle gegevens.

In een architectuur met drie lagen wordt de client niet overbelast met gegevensverwerkingsfuncties, maar vervult hij zijn belangrijkste rol als systeem voor het presenteren van informatie die afkomstig is van de applicatieserver. Een dergelijke interface kan worden geïmplementeerd met behulp van standaard middelen Webtechnologieën - browser, CGI en Java. Dit vermindert de hoeveelheid gegevens die wordt overgedragen tussen de client en de applicatieserver, waardoor u verbinding kunt maken clientcomputers zelfs over langzame lijnen zoals telefoonlijnen. Bovendien kan de clientzijde zo eenvoudig zijn dat deze in de meeste gevallen wordt geïmplementeerd met behulp van universele browser. Maar als u het toch moet veranderen, kan deze procedure snel en pijnloos worden uitgevoerd. De drielaagse client-server-architectuur maakt een preciezere toewijzing van gebruikersrechten mogelijk, omdat zij geen toegangsrechten krijgen tot de database zelf, maar tot bepaalde functies van de applicatieserver. Dit verhoogt de veiligheid van het systeem (vergeleken met conventionele architectuur), niet alleen tegen opzettelijke aanvallen, maar ook tegen foutieve acties van personeel.

Beschouw als voorbeeld een systeem waarvan de verschillende onderdelen op meerdere onderdelen werken verre vriend van andere servers. Laten we aannemen dat er een nieuwe versie van het systeem is ontvangen van de ontwikkelaar, voor installatie daarvan architectuur met twee lagen het is noodzakelijk om alle systeemmodules tegelijkertijd te wijzigen. Als dit niet gebeurt, kan de interactie van oude clients met nieuwe servers tot onvoorspelbare gevolgen leiden, omdat ontwikkelaars meestal niet op een dergelijk gebruik van het systeem rekenen. In een architectuur met drie lagen is de situatie vereenvoudigd. Het is een feit dat door het veranderen van de applicatieserver en de gegevensopslagserver (dit is gemakkelijk tegelijkertijd te doen, aangezien beide zich meestal in de buurt bevinden), we de set onmiddellijk veranderen beschikbare diensten. De kans op een fout als gevolg van een mismatch tussen de versies van de server- en clientonderdelen wordt dus sterk verminderd. Als binnen nieuwe versie Als een dienst is verdwenen, zullen de interface-elementen die deze in het oude systeem dienden eenvoudigweg niet werken. Als het algoritme van de service is gewijzigd, werkt deze zelfs met de oude interface correct.

Client-serversystemen met meerdere niveaus kunnen vrij eenvoudig worden overgedragen naar webtechnologie. Om dit te doen, volstaat het om het clientgedeelte te vervangen door een universele of gespecialiseerde browser en de applicatieserver aan te vullen met een webserver en kleine serverprocedureaanroepprogramma's . Om deze programma's te ontwikkelen, kunt u beide gebruiken Gemeenschappelijke toegangspoort Interface (CGI) en meer moderne technologie Java.

Er moet ook worden opgemerkt dat in een systeem met drie niveaus nogal wat informatie wordt verzonden via het communicatiekanaal tussen de applicatieserver en de database. Dit vertraagt ​​de berekeningen echter niet, aangezien communicatie gespecificeerde elementen snellere lijnen kunnen worden gebruikt. Dit vereist minimale inspanning, aangezien beide servers zich meestal in hetzelfde pand bevinden. Zo nemen de totale prestaties van het systeem toe: twee mensen werken nu aan één taak. verschillende servers, en de communicatie daartussen kan via de snelste lijnen tegen minimale kosten worden uitgevoerd. Het is waar dat er een probleem is van de consistentie van gezamenlijke berekeningen, dat transactiemanagers – nieuwe elementen van systemen met meerdere niveaus – moeten oplossen.

Client-servertechnologie wordt terecht beschouwd als een van de ‘pijlers’ waarop de moderne wereld computer netwerken. Maar de taken waarvoor het is ontwikkeld behoren geleidelijk tot het verleden, en nieuwe taken en technologieën verschijnen op het toneel, waardoor een heroverweging van de principes van client-server-systemen nodig is. Eén van deze technologieën is het World Wide Web.

Gebruik van technologie hypertekstdocumenten intern op te bouwen informatie-infrastructuur Het bedrijf werd gestimuleerd door de snelle ontwikkeling van allerlei client-serversystemen. Sommige mensen proberen webtechnologie te contrasteren met client-server-architectuur, maar dit is feitelijk misleidend zakelijk internet is een ontwikkeling van deze architectuur. We kunnen zeggen dat het websysteem een ​​client-server-architectuur heeft, dat wil zeggen dat u met één client verbinding kunt maken met veel servers. Webbrowser die biedt gebruiksvriendelijke interface dat de gebruiker toegang krijgt tot informatie is slechts het topje van de ijsberg hoogste niveau Websystemen. Naast de interface moet elk informatiesysteem niveaus van gegevensverwerking en -opslag hebben. Intranetontwikkelaars hebben vaak problemen met de juiste afstemming Webwerk met andere elementen van het systeem, zoals databases. Een veelbelovende manier om dit probleem op te lossen is het gebruik van multi-tier client-server-architecturen. Laten we, om de voordelen ervan te begrijpen, een conventioneel client-serversysteem eens nader bekijken.

Klassieke client-serverarchitectuur

De term ‘client-server’ betekent een architectuur van een softwarepakket waarin de functionele onderdelen ervan samenwerken volgens het ‘request-response’-schema. Als we twee op elkaar inwerkende delen van dit complex beschouwen, dan vervult een van hen (de client) een actieve functie, dat wil zeggen, het initieert verzoeken, en de andere (de server) reageert er passief op. Naarmate het systeem zich ontwikkelt, kunnen rollen bijvoorbeeld veranderen programma blok zal tegelijkertijd de functies van een server uitvoeren in relatie tot het ene blok en een client in relatie tot een ander blok.

Houd er rekening mee dat elk informatiesysteem ten minste drie functionele hoofdonderdelen moet hebben: modules voor gegevensopslag, gegevensverwerking en gebruikersinterface. Elk van deze onderdelen kan onafhankelijk van de andere twee worden geïmplementeerd. Zonder de programma's te wijzigen die worden gebruikt om gegevens op te slaan en te verwerken, kunt u bijvoorbeeld de gebruikersinterface wijzigen zodat dezelfde gegevens worden weergegeven in de vorm van tabellen, grafieken of histogrammen. Zonder de gegevenspresentatie- en opslagprogramma's te wijzigen, kunt u de verwerkingsprogramma's wijzigen, bijvoorbeeld door het algoritme te wijzigen Zoek volledige text. Ten slotte kunt u, zonder de programma's voor het presenteren en verwerken van gegevens te wijzigen, de software voor het opslaan van gegevens wijzigen, bijvoorbeeld door naar een ander bestandssysteem te verhuizen.

In een klassieke client-serverarchitectuur moeten de drie hoofdonderdelen van de applicatie over twee fysieke modules worden verdeeld. Doorgaans bevindt software voor gegevensopslag zich op een server (bijvoorbeeld een databaseserver), de gebruikersinterface bevindt zich aan de clientzijde, maar de gegevensverwerking moet worden verdeeld tussen de client- en serveronderdelen. Dit is het belangrijkste nadeel van de tweelaagse architectuur, waarvan er meerdere zijn onaangename kenmerken, wat de ontwikkeling van client-serversystemen enorm bemoeilijkt.

Bij het splitsen van algoritmen voor gegevensverwerking is het noodzakelijk om het gedrag van beide delen van het systeem te synchroniseren. Alle ontwikkelaars moeten volledige informatie hebben over laatste wijzigingen wijzigingen die in het systeem zijn aangebracht en deze wijzigingen begrijpen. Dit schept grote moeilijkheden bij de ontwikkeling van client-serversystemen, de installatie en het onderhoud ervan, aangezien het noodzakelijk is aanzienlijke inspanningen te besteden aan het coördineren van acties verschillende groepen specialisten. Er ontstaan ​​​​vaak tegenstrijdigheden in de acties van ontwikkelaars, en dit vertraagt ​​​​de ontwikkeling van het systeem en dwingt hen om kant-en-klare en beproefde elementen te veranderen.

Om inconsistentie tussen verschillende elementen van de architectuur te voorkomen, proberen ze gegevensverwerking uit te voeren op een van de twee fysieke delen: aan de clientzijde (thick client) of op de server (thin client, of een architectuur die 2,5-tier client wordt genoemd). server"). Elke benadering heeft zijn nadelen. In het eerste geval wordt het netwerk ten onrechte overbelast, omdat er onverwerkte en dus redundante gegevens doorheen worden verzonden. Bovendien worden systeemondersteuning en -wijzigingen moeilijker, omdat het vervangen van een rekenalgoritme of het corrigeren van een fout een gelijktijdige volledige vervanging van alle interfaceprogramma's vereist, anders kunnen er fouten of inconsistenties in de gegevens optreden. Als alle informatieverwerking op de server wordt uitgevoerd (als dit überhaupt mogelijk is), ontstaat het probleem van het beschrijven van ingebouwde procedures en het debuggen ervan. Het punt is dat de taal voor het beschrijven van ingebouwde procedures meestal declaratief is en daarom in principe niet mogelijk is stap voor stap debuggen. Bovendien is een systeem met informatieverwerking op een server absoluut niet over te dragen naar een ander platform, wat een ernstig nadeel is.

De meeste moderne Rapid Application Development (RAD) tools die werken met diverse databanken data, implementeert de eerste strategie, dat wil zeggen dat de dikke client een interface biedt met de databaseserver via ingebedde SQL. Deze optie voor het implementeren van een systeem met een “thick” client biedt, naast de hierboven genoemde nadelen, doorgaans een onaanvaardbaar laag beveiligingsniveau. In banksystemen moeten alle transactieoperatoren bijvoorbeeld het recht krijgen om naar de hoofdtabel van het boekhoudsysteem te schrijven. Bovendien is het vrijwel onmogelijk om dit systeem over te zetten naar webtechnologie, omdat gespecialiseerde clientsoftware wordt gebruikt om toegang te krijgen tot de databaseserver.

De hierboven besproken modellen hebben dus de volgende nadelen.

1. "Vette" klant:

complexiteit van de administratie;

het updaten van de software wordt moeilijker, omdat deze gelijktijdig over het hele systeem moet worden vervangen;

de verdeling van bevoegdheden wordt ingewikkelder, omdat de toegang niet wordt beperkt door acties, maar door tabellen;

het netwerk is overbelast door de overdracht van onverwerkte gegevens;

zwakke gegevensbescherming, omdat het moeilijk is om de bevoegdheden correct te verdelen.

2. "Vette" server:

de implementatie wordt ingewikkelder, omdat talen als PL/SQL niet geschikt zijn om dergelijke software te ontwikkelen en die is er ook niet goede fondsen debuggen;

de prestaties van programma's geschreven in talen als PL/SQL zijn aanzienlijk lager dan die gemaakt in andere talen, wat belangrijk is voor complexe systemen;

programma's geschreven in DBMS-talen werken meestal niet betrouwbaar; een fout daarin kan leiden tot het falen van de gehele databaseserver;

De resulterende programma's zijn volledig niet overdraagbaar naar andere systemen en platforms.

Om deze problemen op te lossen, worden client-server-architecturen met meerdere niveaus (drie of meer niveaus) gebruikt.

Client-server-architecturen met meerdere lagen

Dergelijke architecturen distribueren op intelligentere wijze gegevensverwerkingsmodules, die in dit geval op een of meer afzonderlijke servers draaien. Deze softwaremodules vervullen de functies van een server voor gebruikersinterfaces en een client voor databaseservers. Bovendien kunnen verschillende applicatieservers met elkaar communiceren om het systeem nauwkeuriger te verdelen in functionele eenheden die specifieke rollen vervullen. U kunt bijvoorbeeld een personeelsbeheerserver selecteren die alle functies uitvoert die nodig zijn voor personeelsbeheer. Door er een aparte database aan te koppelen, kunt u alle implementatiedetails van deze server voor gebruikers verbergen, waardoor ze alleen toegang hebben tot de openbare functies. Bovendien is zo'n systeem heel gemakkelijk aan te passen aan het web, omdat het gemakkelijker is om HTML-formulieren te ontwikkelen waarmee gebruikers toegang kunnen krijgen tot bepaalde functies van de database dan tot alle gegevens.

In een architectuur met drie lagen wordt de thin client niet overbelast met gegevensverwerkingsfuncties, maar vervult hij zijn belangrijkste rol als systeem voor het presenteren van informatie afkomstig van de applicatieserver. Een dergelijke interface kan worden geïmplementeerd met behulp van standaard webtechnologietools: een browser, CGI en Java. Hierdoor wordt de hoeveelheid gegevens die tussen de client en de applicatieserver wordt overgedragen verminderd, waardoor clientcomputers zelfs via langzame lijnen, zoals telefoonlijnen, verbinding kunnen maken. Bovendien kan de clientzijde zo eenvoudig zijn dat deze in de meeste gevallen wordt geïmplementeerd met behulp van een universele browser. Maar als u het toch moet veranderen, kan deze procedure snel en pijnloos worden uitgevoerd. De drielaagse client-server-architectuur maakt een preciezere toewijzing van gebruikersrechten mogelijk, omdat zij geen toegangsrechten krijgen tot de database zelf, maar tot bepaalde functies van de applicatieserver. Dit verhoogt de veiligheid van het systeem (vergeleken met conventionele architectuur), niet alleen tegen opzettelijke aanvallen, maar ook tegen foutieve acties van personeel.

Neem als voorbeeld een systeem waarvan de verschillende onderdelen op verschillende servers op afstand van elkaar draaien. Laten we aannemen dat de ontwikkelaar een nieuwe versie van het systeem heeft ontvangen, om te installeren waarvoor het in een architectuur op twee niveaus noodzakelijk is om tegelijkertijd alle systeemmodules te wijzigen. Als dit niet gebeurt, kan de interactie van oude clients met nieuwe servers tot onvoorspelbare gevolgen leiden, omdat ontwikkelaars meestal niet op een dergelijk gebruik van het systeem rekenen. In een architectuur met drie lagen is de situatie vereenvoudigd. Het feit is dat door het veranderen van de applicatieserver en de gegevensopslagserver (dit is gemakkelijk tegelijkertijd te doen, omdat ze zich meestal in de buurt bevinden), we onmiddellijk de reeks beschikbare services veranderen. De kans op een fout als gevolg van een mismatch tussen de versies van de server- en clientonderdelen wordt dus sterk verminderd. Als een dienst in de nieuwe versie verdwijnt, zullen de interface-elementen die hem in het oude systeem bedienden eenvoudigweg niet werken. Als het algoritme van de service is gewijzigd, werkt deze zelfs met de oude interface correct.

Client-serversystemen met meerdere niveaus kunnen vrij eenvoudig worden overgedragen naar webtechnologie. Om dit te doen, volstaat het om het clientgedeelte te vervangen door een universele of gespecialiseerde browser en de applicatieserver aan te vullen met een webserver en kleine serverprocedureaanroepprogramma's . Zowel de Common Gateway Interface (CGI) als modernere Java-technologie kunnen worden gebruikt om deze programma's te ontwikkelen.

Er moet ook worden opgemerkt dat in een systeem met drie niveaus nogal wat informatie wordt verzonden via het communicatiekanaal tussen de applicatieserver en de database. Dit vertraagt ​​de berekeningen echter niet, omdat er snellere lijnen kunnen worden gebruikt om deze elementen met elkaar te verbinden. Dit vereist minimale inspanning, aangezien beide servers zich meestal in hetzelfde pand bevinden. De totale prestaties van het systeem nemen dus toe: twee verschillende servers werken nu aan één taak en de communicatie daartussen kan worden uitgevoerd via de snelste lijnen met minimale kosten fondsen. Het is waar dat er een probleem is van de consistentie van gezamenlijke berekeningen, dat transactiemanagers – nieuwe elementen van systemen met meerdere niveaus – moeten oplossen.

Transactiemanagers

Een kenmerk van multi-tier architecturen is het gebruik van transactiemanagers (MT's), waardoor één applicatieserver gelijktijdig kan communiceren met meerdere databaseservers. Hoewel Oracle-servers hebben een mechanisme om gedistribueerde transacties uit te voeren, maar als de gebruiker een deel van de informatie in de Oracle-database, een deel in de Informix-database en een deel in tekstbestanden opslaat, dan is een transactiemanager onmisbaar. MT wordt gebruikt om gedistribueerde heterogene operaties te beheren en acties te coördineren diverse componenten informatie Systeem. Opgemerkt moet worden dat bijna elke complexe software het gebruik van een transactiemanager vereist. Banksystemen moeten bijvoorbeeld verschillende transformaties van documentrepresentaties uitvoeren, dat wil zeggen gelijktijdig werken met gegevens die zowel in databases als in reguliere bestanden zijn opgeslagen - dit zijn de functies die MT helpt uit te voeren.

Een transactiemanager is een programma of een reeks programma's die kunnen worden gebruikt om de werking van verschillende componenten van een informatiesysteem te coördineren. Logischerwijs is MT verdeeld in verschillende delen:

Communication Manager regelt de uitwisseling van berichten tussen informatiesysteemcomponenten;

Authorization Manager biedt gebruikersauthenticatie en verificatie van hun toegangsrechten;

de Transactiemanager beheert gedistribueerde operaties;

de Log Manager bewaakt het herstel en het terugdraaien van gedistribueerde bewerkingen;

De Lock Manager zorgt voor een correcte toegang tot gedeelde gegevens.

Meestal wordt de communicatiemanager gecombineerd met de autorisatiemanager en werkt de transactiemanager samen met slot- en slotmanagers. systeemrecords. Bovendien wordt zo'n manager zelden in het pakket opgenomen, omdat de functies ervan (administratie bijhouden, bronnen distribueren en bewerkingen controleren) meestal worden uitgevoerd door de database zelf (bijvoorbeeld Oracle).

Begin jaren zeventig verschenen de eerste transactiemanagers. (bijv. CICS); Sindsdien zijn ze enigszins ideologisch veranderd, maar zeer significant - technologisch. De grootste ideologische veranderingen vonden plaats in de communicatiemanager, toen nieuwe objectgeoriënteerde technologieën (CORBA, DCOM, enz.) op dit gebied verschenen. Vanwege de snelle ontwikkeling van communicatiemedia in de toekomst kunnen we dit verwachten wijdverbreid gebruik verschillende soorten transactiemanagers.

Een client-serverarchitectuur met meerdere niveaus kan dus gedistribueerd computergebruik aanzienlijk vereenvoudigen, waardoor het niet alleen betrouwbaarder, maar ook toegankelijker wordt. De komst van tools zoals Java maakt het voor applicatieservers gemakkelijker om met clients te communiceren, en objectgeoriënteerde transactiemanagers zorgen ervoor dat applicatieservers samenwerken met databases. Als gevolg hiervan worden alle voorwaarden geschapen voor het creëren van complexe gedistribueerde informatiesystemen die effectief gebruik maken van alle voordelen van moderne technologieën.

Materiaal voor dit artikel is geleverd door ASoft; tel. 261-5724. U kunt contact opnemen met Valery Korzhov via .

]. Hierdoor kunt u de functies van het opslaan, verwerken en presenteren van gegevens nog meer scheiden effectief gebruik mogelijkheden van servers en clients.

Onder de multi-tier client-server-architectuur is de drielaagse architectuur de meest voorkomende ( architectuur met drie lagen, drie lagen), waarbij wordt uitgegaan van de aanwezigheid van de volgende applicatiecomponenten: een clientapplicatie (meestal een “thin client” of terminal genoemd) verbonden met applicatie server, die op zijn beurt verbonden is met database server [ , ].

rijst. 5.4.

Rijst. 5.4. Weergave van een multi-tier client-server-architectuur

• Een terminal is een interfacecomponent (meestal grafisch) die het eerste niveau, de daadwerkelijke toepassing, voor de eindgebruiker vertegenwoordigt. Het eerste niveau mag geen directe verbindingen hebben met de database (om veiligheidsredenen), geladen zijn met kernbedrijfslogica (om redenen van schaalbaarheid) en de applicatiestatus opslaan (om redenen van betrouwbaarheid). De eenvoudigste bedrijfslogica kan en wordt meestal op het eerste niveau geplaatst: autorisatie-interface, versleutelingsalgoritmen, controle van ingevoerde waarden op geldigheid en conformiteit met het formaat, eenvoudige handelingen (sorteren, groeperen, tellen van waarden) met gegevens die al op de computer zijn geladen. terminal.
• Applicatieserver gelegen op het tweede niveau. Het tweede niveau bevat het grootste deel van de bedrijfslogica. Daarbuiten blijven fragmenten die naar terminals worden geëxporteerd, evenals opgeslagen procedures en triggers die zijn ondergedompeld in het derde niveau.
• Database server biedt gegevensopslag en is verplaatst naar het derde niveau. Meestal is dit een standaard relationeel of objectgeoriënteerd DBMS. Als het derde niveau een database is, samen met opgeslagen procedures, triggers en een schema dat de applicatie in termen beschrijft relationeel model, dan wordt het tweede niveau geconstrueerd als software-interface, dat clientcomponenten koppelt aan databaseapplicatielogica.

In de eenvoudigste configuratie fysiek applicatieserver kan gecombineerd worden met database server op één computer waarop een of meer terminals via een netwerk zijn aangesloten.

In de “juiste” (qua beveiliging, betrouwbaarheid, schaalbaarheid) configuratie database server zich op een speciale computer (of cluster) waarop een of meer applicatieservers, waarop op hun beurt terminals via het netwerk zijn aangesloten.

De voordelen van deze architectuur zijn [ , , , ]:

• clientsoftware vereist geen beheer;
• schaalbaarheid;
• configureerbaarheid – door de niveaus van elkaar te isoleren, kunt u het systeem snel en eenvoudig opnieuw configureren wanneer zich storingen voordoen of tijdens gepland onderhoud op een van de niveaus;
• hoge beveiliging;
• hoge betrouwbaarheid;
• lage vereisten voor kanaal- (netwerk)snelheid tussen terminals en applicatie server;
• lage eisen aan de prestaties en technische kenmerken van terminals, wat resulteert in een verlaging van hun kosten.

• de complexiteit van het servergedeelte en als gevolg daarvan de kosten voor beheer en onderhoud groeien;
• hogere complexiteit bij het maken van applicaties;
• moeilijker in te zetten en te beheren;
• hoge prestatie-eisen applicatieservers En database server en dus de hoge kosten van serverapparatuur;
• hoge eisen aan kanaal(netwerk)snelheid tussen database server En applicatieservers.

1. Prestatie;
2. Presentatie laag;
3. Logisch niveau;
4. Gegevenslaag;
5. Gegevens.

Rijst. 5.5. Vijf niveaus van multi-tier client-server-architectuur

De presentatie omvat alle informatie die direct aan de gebruiker wordt getoond: gegenereerde HTML-pagina's, stylesheets, afbeeldingen.

De presentatielaag omvat alles wat te maken heeft met de communicatie van de gebruiker met het systeem. De belangrijkste functies van de presentatielaag omvatten het weergeven van informatie en het interpreteren van gebruikersinvoer en het omzetten ervan in passende bewerkingen in de context van logica en gegevens.

Het logische niveau bevat de belangrijkste functies van het systeem dat is ontworpen om zijn doel te bereiken. Deze functies omvatten berekeningen op basis van ingevoerde en opgeslagen gegevens, het valideren van alle gegevenselementen en het verwerken van opdrachten uit de presentatielaag, en het doorgeven van informatie aan de gegevenslaag.

De datatoegangslaag is een subset van functies die interactie mogelijk maken systemen van derden, die taken uitvoeren ten behoeve van de applicatie.

Systeemgegevens worden meestal opgeslagen in een database.

5.1.6. Gedistribueerde systeemarchitectuur

Dit type systeem is complexer in termen van systeemorganisatie. De essentie gedistribueerd systemen is om lokale kopieën van belangrijke gegevens op te slaan.

Schematisch kan een dergelijke architectuur worden weergegeven zoals weergegeven in Fig. 5.6.

Rijst. 5.6.

Meer dan 95% van de gegevens die bij bedrijfsbeheer worden gebruikt, kunnen zich op één systeem bevinden persoonlijke computer, waardoor de mogelijkheid van zijn onafhankelijke werk wordt gewaarborgd. De stroom aan correcties en aanvullingen die op deze computer gegenereerd wordt, is verwaarloosbaar in vergelijking met de hoeveelheid data die gebruikt wordt. Als u daarom voortdurend gebruikte gegevens op de computers zelf opslaat en de uitwisseling van correcties en toevoegingen aan de opgeslagen gegevens daartussen organiseert, zal het totale verzonden verkeer sterk afnemen. Dit maakt het mogelijk om de vereisten voor communicatiekanalen tussen computers te verminderen en vaker asynchrone communicatie te gebruiken, en dankzij dit betrouwbaar functionerende gedistribueerde informatiesystemen te creëren die gebruik maken van onstabiele communicatie zoals internet, mobiele communicatie, commerciële communicatie. satellietkanalen. En het minimaliseren van het verkeer tussen elementen zal de kosten van het exploiteren van een dergelijke verbinding redelijk betaalbaar maken. Natuurlijk is de implementatie van een dergelijk systeem niet elementair en vereist het oplossen van een aantal problemen, waarvan er één de tijdige gegevenssynchronisatie is.

Elk werkstation is onafhankelijk en bevat alleen de informatie die het nodig heeft om mee te werken. De relevantie van de gegevens in het hele systeem wordt verzekerd door de voortdurende uitwisseling van berichten met andere werkstations. Berichtuitwisseling tussen werkstations kan worden geïmplementeerd verschillende manieren, van het verzenden van gegevens via e-mail voordat gegevens via netwerken worden verzonden.