Schemavalidatie: hoe computers elkaar begrijpen zonder misverstanden
Stel je voor dat je bij de gemeente een formulier invult om een paspoort aan te vragen. Voordat de balieÂmedewerker het accepteert, controleert ze of alle verplichte velden zijn ingevuld, of je geboortedatum echt bestaat en of je postcode uit vier cijfers en twee letters bestaat. Pas als alles klopt, gaat het formulier de administratie in. Schemavalidatie is precies dit proces, maar dan voor computers: software die automatisch controleert of een stuk digitale data — bijvoorbeeld een bestand met bestelgegevens dat via internet tussen twee systemen wordt verstuurd — voldoet aan een vooraf afgesproken 'formulier', het schema.
Dat schema is dus geen fysiek document, maar een technische beschrijving van hoe correcte data eruit moet zien: welke velden verplicht zijn, welk type waarde erin hoort (tekst, getal, datum), en soms zelfs binnen welke grenzen die waarde mag liggen. Zonder zo'n controle zouden computersystemen voortdurend vastlopen op onverwachte of onvolledige data, met kans op crashes, verkeerde berekeningen of — in het slechtste geval — kwetsbaarheden die misbruikt kunnen worden door kwaadwillenden die bewust foutieve data aanbieden.
Wat is het precies?
Computers wisselen data meestal uit in gestandaardiseerde tekstformaten, waarvan JSON (JavaScript Object Notation) en XML (Extensible Markup Language) de bekendste zijn. Beide zijn manieren om gestructureerde informatie op te schrijven, vergelijkbaar met hoe een adres uit straat, huisnummer, postcode en plaats bestaat.
Een schema legt vast welke structuur zo'n bestand moet hebben. Voor JSON-data gebeurt dat meestal met JSON Schema, een specificatie waarmee je bijvoorbeeld kunt zeggen: 'het veld leeftijd is verplicht, moet een geheel getal zijn en mag niet negatief zijn'. Voor XML-bestanden bestaat een vergelijkbaar systeem genaamd XSD (XML Schema Definition), een standaard van het World Wide Web Consortium (W3C).
Het valideren zelf gebeurt met een stukje software, een validator, die het schema en de binnenkomende data naast elkaar legt. Klopt alles, dan gaat de data door naar de volgende stap in het systeem. Klopt er iets niet, dan geeft de validator een foutmelding terug — idealiter met een duidelijke aanwijzing wélk veld fout is en waarom, zodat de afzender het kan herstellen.
Naast JSON Schema en XSD bestaan er ook schematalen voor data die niet als leesbare tekst maar in compacte, binaire vorm wordt verstuurd — sneller te verwerken, maar niet met het blote oog leesbaar. Bekende voorbeelden zijn Protocol Buffers (ontwikkeld door Google) en Apache Avro, beide veel gebruikt wanneer grote hoeveelheden data tussen systemen stromen.
Wat wil men ermee bereiken?
Het belangrijkste doel is vroegtijdige foutdetectie. Een fout die je meteen bij binnenkomst van data ontdekt, is veel goedkoper te herstellen dan een fout die pas dieper in een systeem tot problemen leidt — bijvoorbeeld een verkeerd bedrag dat al is doorgeboekt naar een boekhoudsysteem voordat iemand het opmerkt.
Een tweede doel is interoperabiliteit: het vermogen van systemen van verschillende bedrijven of overheidsinstanties om zonder handmatig ingrijpen met elkaar te communiceren. Als twee partijen vooraf afspreken welk schema ze gebruiken, hoeven ze niet steeds opnieuw te overleggen over de exacte vorm van de data die ze uitwisselen.
Daarnaast functioneert een schema vaak automatisch als documentatie: ontwikkelaars die willen weten welke data een systeem verwacht, kunnen het schema raadplegen in plaats van te gokken of de broncode te doorspitten. Sommige tools genereren zelfs automatisch testformulieren, voorbeeldcode of interactieve documentatie op basis van een schema.
Tot slot speelt beveiliging een rol. Door strikt te controleren wat een systeem accepteert, wordt het lastiger om via geknutselde of te grote invoer een systeem te laten crashen of tot onbedoeld gedrag te dwingen — al is schemavalidatie op zichzelf geen volledige beveiligingsoplossing, eerder één laag in een bredere verdediging.
Voorbeelden uit de praktijk
Een bekend voorbeeld is de opkomst van OpenAPI (voorheen Swagger geheten), een specificatie waarmee bedrijven de structuur van hun webdiensten (API's) beschrijven. Betaaldienst Stripe is een veelgenoemd voorbeeld van een bedrijf dat zijn API-documentatie en validatie op deze manier inricht, zodat ontwikkelaars wereldwijd exact weten welke data ze moeten aanleveren.
Binnen Kubernetes, het populaire open source-systeem voor het beheren van containers (kleine, geïsoleerde softwareomgevingen) op servers, wordt elk configuratiebestand vóór toepassing gevalideerd tegen een OpenAPI-gebaseerd schema. Zo voorkomt het systeem dat een typefout in een configuratiebestand een heel serverpark ontregelt.
In de wereld van streaming data — continue stromen gebeurtenissen, zoals sensormetingen of transactieberichten — wordt Apache Avro vaak gecombineerd met Apache Kafka, een systeem voor het verwerken van dit soort datastromen in real time. Bedrijven met grote datavolumes gebruiken dit om te garanderen dat berichten die vandaag worden verstuurd, ook morgen nog correct te lezen zijn door systemen die intussen zijn bijgewerkt.
Google gebruikt zijn eigen Protocol Buffers al sinds de jaren 2000 intern, onder meer voor de communicatie tussen de duizenden diensten die samen producten als Zoeken en Gmail draaiende houden, en heeft het formaat later opengesteld voor de rest van de wereld via het bijbehorende communicatieprotocol gRPC.
In meer traditionele sectoren, zoals de logistiek en de zorg, wordt al decennialang gewerkt met XSD-schema's binnen zogeheten SOAP-webservices en EDI-berichten (Electronic Data Interchange) — een minder trendy maar nog altijd wijdverspreide manier om bijvoorbeeld pakketgegevens of medische declaraties tussen organisaties uit te wisselen.
Hoe ver is de techniek?
Schemavalidatie is geen nieuwe of experimentele technologie, maar een volwassen praktijk die zich nog altijd doorontwikkelt. XSD is sinds 2012 beschikbaar in versie 1.1 als officiële aanbeveling van het W3C en wordt inmiddels als stabiel en weinig veranderend beschouwd.
JSON Schema is dynamischer: de specificatie wordt niet door één formele standaardisatieorganisatie beheerd, maar door een open community, en heeft door de jaren heen meerdere 'draft'-versies gekend (waaronder Draft-07 en de latere 2019-09 en 2020-12). Dat gebrek aan één definitieve, formeel bekrachtigde versie is tegelijk een kracht — snelle aanpassing aan de praktijk — en een bron van fragmentatie, omdat niet elke validator-tool elke draft-versie identiek ondersteunt.
Een blijvend obstakel is schema-evolutie: wat doe je als de structuur van je data na verloop van tijd moet veranderen, terwijl oudere systemen nog met het oude schema werken? Formaten als Avro en Protocol Buffers zijn juist mede ontworpen om dit soort achterwaartse compatibiliteit te vergemakkelijken, maar het blijft een terugkerend praktisch probleem, ook bij JSON Schema en XSD.
Verder is er een reële afweging tussen grondigheid en snelheid: uitgebreide validatie kost rekentijd, wat bij systemen die miljoenen berichten per seconde verwerken, kan gaan schuren met prestatie-eisen. In de praktijk kiezen veel organisaties er daarom voor om alleen op kritieke plekken in een systeem volledig te valideren, en elders lichtere controles te gebruiken.
Wie werken eraan?
Anders dan bij veel opkomende technologieën is er geen enkele partij die schemavalidatie 'bezit'. XML Schema wordt beheerd door het World Wide Web Consortium (W3C), het internationale standaardisatieorgaan voor het web. JSON Schema wordt onderhouden door een vrijwillige open source-gemeenschap rond de website json-schema.org, zonder centrale commerciële eigenaar.
De OpenAPI Initiative, ondergebracht bij de Linux Foundation, beheert de OpenAPI-specificatie die op zijn beurt weer op JSON Schema leunt voor het beschrijven van API-datastructuren. Google is de drijvende kracht achter Protocol Buffers en gRPC, terwijl Apache Avro wordt onderhouden binnen de Apache Software Foundation, een stichting die tientallen open source-projecten host met bijdragen van zowel vrijwilligers als bedrijven.
Daarnaast dragen ontelbare individuele ontwikkelaars en kleinere softwarebedrijven bij aan de validator-bibliotheken die dit alles in de praktijk bruikbaar maken, zoals de populaire JavaScript-bibliotheek AJV voor JSON Schema-validatie. Het is dus vooral een gedecentraliseerd, door de gemeenschap gedreven vakgebied, met grote techbedrijven als belangrijke gebruikers en soms mede-financiers, maar zonder één dominante marktpartij.