Koppelen met het koppie
Zinnig gebruik maken van
verschillende typen interfaces
Bij de besluitvorming over
het ontwikkelen of aanpassen van systemen vormen interfaces
vaak een sluitpost in de planning en de begroting.
Begrijpelijk dat de focus ligt op systemen die directe
ondersteuning bieden aan processen en producten. Maar wat is
een systeem of proces zonder aansluiting op andere systemen of
processen? Ferdinand Geuther over de ins en outs van
interfaces.
Wat is een interface? Het Engels woordenboek zegt: raakvlak,
aansluiting, contact, koppeling. Interfaces binnen de
it-wereld kunnen worden beschouwd als koppelstukken waarmee
gegevens zijn uit te wisselen. De kracht van de interface
schuilt echter ook in de mogelijkheid om systemen te kunnen
ont-koppelen en daardoor separaat te kunnen ontwikkelen
en testen, en ook afzonderlijk in bedrijf te hebben. Door het
inzetten van gestandaardiseerde interfaces kunnen systemen van
verschillende origines samenwerken en wordt ook de
uitwisselbaarheid en dus de concurrentie
bevorderd.
Interfaces maken het koppelen met de
buitenwereld makkelijker. Simpel dus. Maar schijn bedriegt.
Zelfs een eenvoudige koppeling als de stekker voor het
elektriciteitsnet kan ons parten spelen als we in het
buitenland zijn. Een interface is alleen effectief als alle
betrokken partijen dezelfde standaarden hanteren. Daarmee
hebben we het belangrijkste aspect te pakken: afspraken moeten
worden gemaakt, eenduidig vastgelegd en vooral worden
nageleefd. Wijzigingen moeten met alle partijen worden
afgestemd en door hen worden goedgekeurd - vaak een moeizaam
en langdurig proces.
Die standaarden beslaan vele
terreinen: gegevensdefinities, datacommunicatieprotocollen,
systeemsoftware, apparatuur, kabels, enzovoort. Is de
standaard eenmaal beschikbaar, dan kunnen zich in de
dagelijkse praktijk allerlei problemen voordoen. Denk aan
leveranciers die de standaard uitbreiden of er een eigen
interpretatie van geven.
Mate van
interactie
Alvorens in te gaan op de
praktische aspecten bij het ontwerp en het beheer van
interfaces, eerst iets over de mate van interactie tussen de
systemen die via een interface met elkaar moeten communiceren.
Er zijn drie niveaus te onderscheiden: directe interactie,
bijna directe interactie en indirecte interactie.
Directe
interactie (real time) houdt in dat de systemen, applicaties
of processen zonder tijdvertraging met elkaar moeten kunnen
communiceren. Dit geldt bijvoorbeeld voor de besturing van
complexe of tijdkritische systemen, zoals
vliegtuignavigatiesystemen. Interfaces die dit ondersteunen,
moeten zeer robuust en ongevoelig voor storingen zijn, en geen
tijdvertraging opleveren.
Bijna directe interactie (near
real time) is vergelijkbaar met directe interactie, maar hier
zijn korte wachttijden acceptabel. Denk bijvoorbeeld aan het
invoeren van een order via internet waar enkele seconden
wachttijd het orderproces niet zullen verstoren. Doordat er
minder zware eisen worden gesteld aan de interface kan die
efficiënter omgaan met beschikbare verbindingen of
verwerkingscapaciteit door gegevens op te sparen tot kleine
efficiënt verwerkbare eenheden
(store-and-forward).
Indirecte interactie (filetransfer)
houdt in dat de systemen onafhankelijk van elkaar kunnen
opereren en slechts af en toe, periodiek, (niet tijd-kritisch)
gegevens moeten uitwisselen. De gegevens worden 'opgespaard'
en als één bestand periodiek verstuurd. Een goedkope en
robuuste oplossing.
Implementatievormen
Voor 'near
real time' en 'filetransfer' zijn verschillende oplossingen
ontwikkeld. Hieronder volgen enkele bekende
vormen.
Transactieverwerking, een vorm van 'near
real time' verwerking. Alle gegevens die benodigd zijn voor
één logische transactie -bijvoorbeeld het invoeren van
klantgegevens- worden als één set verstuurd en verwerkt, en de
resultaten worden als een set terugontvangen en verwerkt. In
het geval van een onderbroken of foutieve verwerking kan de
oorspronkelijke situatie worden hersteld (roll-back). Een
succesvolle verwerking (beide systemen bevinden zich in de
nieuwe situatie) wordt door middel van een 'commit'-commando
bevestigd.
RPC, 'remote procedure call'. De zendende
partij start een proces op het ontvangende systeem teneinde
bepaalde gegevens uit dat systeem op te
vragen.
Publish/subscribe. De zender (publisher)
stelt gegevens beschikbaar voor verdere verwerking; er zijn
meerdere partijen (subscribers) die dat kunnen doen en de
eerste die beschikbaar is, pakt zo'n set op en verwerkt die.
'Publisher' en 'subscribers' worden ook wel 'agents' genoemd.
De fysieke knooppunten worden 'clients' genoemd. 'Posting' is
het bekend maken aan de clients dat er berichten voor hen
zijn. Meestal wordt gebruik gemaakt van een wachtrij (queue)
mechanisme.
Passief en
actief
Een passieve interface dient louter
als koppel- of transportmedium en voert zelf geen bewerkingen
of controles uit. Hij vergt weinig beheerinspanning; als hij
eenmaal werkt heb je er verder weinig omkijken naar.
Een
actieve interface coördineert (dirigeert) het gegevensverkeer;
verzorgt controles en rapportages, converteert (omzetten van
formaat en/of structuur), filtert, zorgt voor tijdelijke
opslag (bijvoorbeeld om snelheidsverschillen op te vangen),
enzovoort. Om in business-termen te spreken: een actieve
interface voegt waarde toe, en vergt beheerinspanning.
Snelheden, conversies, controles, en tijdelijke opslag kunnen
in de praktijk anders uitpakken dan voorzien. Een en ander
moet dus worden bewaakt en waar nodig worden
bijgesteld.
Middleware
Alle
facetten van interfaces komen tezamen in het begrip
'middleware'. Hiervan bestaan verschillende definities. In
feite komt het neer op een set van programma's die dienen als
generiek koppelplatform tussen systemen. De aan te sluiten
systemen hoeven dan slechts één koppeling met de middleware te
ontwikkelen, en niet meer veel interfaces met alle andere
systemen. Dat is een groot winstpunt, vooral als er veel
wisseling zit in die andere systemen. Er zijn
softwareleveranciers die middleware als hun kernactiviteit
hebben en daarmee dus de zorg voor het ontwerp en onderhoud
van deze interfacesystemen uit handen nemen van de eigenaren
van de te koppelen systemen. Het onderwerp middleware is zo
breed, dat hier slechts een tip van de sluier kan worden
opgelicht.
De basis van middleware wordt gevormd door een
berichtensysteem (messagebus), dat ervoor zorgt dat alle
deelnemende systemen met elkaar kunnen communiceren en dat de
aflevering van de berichten garandeert. Daarnaast ondersteunt
hij het opzoeken of wijzigen van gegevens in een ander
systeem. Verder zorgt de middleware voor het kopiëren
(repliceren) en synchroon houden van gegevensbestanden van
verschillende systemen. Aan deze drie basisfuncties kunnen
verscheidene extra functies worden toegevoegd, zoals
beveiliging, datatransformatie, validaties, conversies, en
workflowmanagement..
Techniek en
gegevens
Bij het ontwerpen van interfaces
krijgen de gegevens en de techniek meestal de grootste
aandacht. Dat is begrijpelijk, maar er zijn andere belangrijke
factoren waar aandacht aan besteed moet worden: processen,
eigendom en beheer en contractuele afspraken.
Techniek
behelst de fysieke koppeling door middel van bijvoorbeeld
kabels, stekkers, computerhardware, software en
netwerkprotocollen. Dit is redelijk recht-toe-recht-aan en
leveranciers bieden veelal kant-en-klaar oplossingen. Toch
zijn er legio problemen die zich hier kunnen voordoen, zoals
verschillende versies van software en landspecifieke kenmerken
(denk aan lettertekens en toetsenbord lay-out). Hieraan wordt
altijd aandacht besteed, want als de techniek niet werkt,
werkt de interface überhaupt niet. Dat ziet iedereen, zelfs
managers, snel in.
Voor gegevens die moeten worden
overgebracht, ligt dat ietwat anders. Fouten hoef je niet
direct te merken. Het lijkt of de interface netjes werkt (de
techniek doet het) maar pas bij een controle of bij een
periodeafsluiting blijken de resultaten niet te kloppen. Het
is dus erg belangrijk om veel aandacht te besteden aan de
gegevensdefinities en -structuren. Hierbij kan onderscheid
worden gemaakt tussen de gegevens zelf (inhoud), de
meta-gegevens -gegevens over de gegevens- zoals structuren
(datamodel; entiteiten, attributen en afhankelijkheden),
definities (dictionary en repository) en controle- en
besturingsgegevens. Met name aan die laatste groep wordt
meestal een lage prioriteit toegekend en deze wordt daardoor
laat of niet meegenomen in het ontwerp. Maar 'meten is weten',
dus zorg dat besturingsgegevens en managementinformatie van
meet af aan in het ontwerp opgenomen zijn. Hierdoor is veel
geld te besparen in de productiefase!
Processen
en eigendom
Het koppelen van systemen heeft
pas effect als beide systemen op de juiste momenten de juiste
gegevens aan elkaar overdragen. Er zijn dus nauwkeurige
afspraken nodig over de processen van gegevensverzending en
ontvangst: tijdstippen, frequenties, controles, herstel c.q.
herverzending, beveiliging, enzovoort. In het kader van de
snelheid moeten processen en techniek van de interface in
balans zijn. Het heeft weinig zin om real-time technieken te
gebruiken als de wellicht deels handmatige processen dit niet
kunnen aansturen of bijbenen.
Wees ook alert op de
uitzonderingen. Die zorgen meestal voor veel stagnatie. Wel
eens voor een kassa staan wachten als het artikel niet
geprijsd was en de winkelbediende opgeroepen moest worden?
Optimale processen omvatten daarom ook goede
foutafhandelingsinstructies.
Interfaces die ontstaan zijn
vanuit een van de systemen, zijn meestal ook eigendom van de
betreffende systeemeigenaar. Die zal zorgen voor de
standaarden en het beheer. Het kan echter voordelen hebben om
het eigendom of de zeggenschap te leggen bij een neutrale
instantie. Dat kan een samenwerkingsverband zijn van de
betrokken partijen, maar ook een onafhankelijke derde partij.
In elk geval moet duidelijk worden vastgesteld wie de
zeggenschap heeft, welke rechten en plichten de deelnemende
partijen hebben, hoe wijzigingsvoorstellen kunnen worden
ingediend en hoe wijzigingen worden
doorgevoerd.
Contracten
Tijdens de bouw van
een systeem kan veel worden geregeld of opgelosd doordat
iedereen - ontwerpers, bouwers, testers, gebruikers en
opdrachtgever - er intensief bij betrokken is. Na oplevering
ligt dat anders. Na verloop van tijd sijpelt de
achtergrondkennis uit de organisatie. Productie en volumes
nemen echter toe (als de business okay is!), en hiermee ook de
druk op processen, systemen en interfaces. Daarom zijn goede
contractuele afspraken uitermate belangrijk. Bij interfaces
gaat het vooral om afspraken over het beheer van de interface
(techniek en software) en over de gegevens die via de
interface worden verstuurd.
Het eerste aspect wordt
geregeld middels 'service level agreements', waarin onder meer
beschikbaarheid, prestatie-eisen, betrouwbaarheid, technische
eisen, veranderingsbeheer en rapportage-eisen worden
vastgelegd.
Voor de gegevens worden
gegevensleveringsovereenkomsten opgesteld. Hierin worden
afspraken vastgelegd inzake inhoud, betekenis en structuur van
de gegevens, de betrokken partijen en de
wijzigingsprocedure.
Voordelen
Interfaces
-(ont)koppelstukken zijn de poorten naar de omgeving en bieden
voordelen met betrekking tot bewaking, synchronisatie,
opvangen van snelheidsverschillen, conversies,
onafhankelijkheid en uitwisselbaarheid.
Houd rekening met de afspraken die met alle partijen gemaakt
moeten worden, met duidelijke beheerrichtlijnen en contracten,
en vergeet vooral niet de operationele kosten.
| Ferdinand G. Geuther It-architect, KPN Broadband
Networks. |
 | |