Ab sofort unterstützt GEFEG.FX die Entwicklung von APIs auf Basis von OpenAPI 3.x. Und das Beste ist: Man kann die bestehenden Datenmodelle und Nachrichten in APIs weiterverwenden.

GEFEG.FX ist bekannt als der ‚Hidden Champion‘ für Design-, Dokumentations- und Mapping-Software, wenn es um klassische EDI(FACT)-Nachrichten, XML Nachrichten, Datenmodelle und Standards geht. Kurz: Seit fast vier Jahrzehnten unterstützt GEFEG die Digitalisierung von Unternehmen rund um den Globus. Von daher ist es der natürliche nächste Schritt auch die Transformation in die Welt der Web-APIs zu begleiten. Mit der neuen Version von GEFEG.FX kann man nun all diese Datenmodelle in APIs wiederverwenden.

Erfolgreiche Pilotprojekte von Automobil über BlockChain bis Marketing

Wenn es um die Entwicklung und das Setzen von Standards geht, muss dies von der eingesetzten Software optimal unterstützt werden. GEFEG.FX wird permanent weiterentwickelt und um neue Funktionalitäten ergänzt. Die Unterstützung von APIs ist jedoch ein größerer Schritt gewesen. Ein eigener Programmbereich wurde geschaffen und wird noch weiter ausgebaut. Für GEFEG ist es daher besonders wichtig, hier die gewohnte Zuverlässigkeit und Qualität zu bieten. Wir konnten mehrere Pilotprojekte gewinnen, bei denen wir die neuen Module erfolgreich ausprobiert haben. Die Rückmeldungen unserer Kunden sind somit sofort in die Entwicklung eingeflossen um die Nutzbarkeit des neuen API-Moduls sicherstellen.

Unterstützung von OpenAPI 3.0 und OpenAPI 3.1 im Swagger und YAML-Format

Für viele ist „Swagger“ ein Begriff. Warum? Weil für viele Jahre Swagger einer der Standards im Web für APIs war. Daher gibt es noch viel Software im Markt, die das Swagger 2.0 – Format unterstützt. Doch dieses Format ist seit einigen Jahren überholt und OpenAPI ist der Nachfolger. Seit Frühjahr 2021 steht OpenAPI in der Version 3.1 zur Verfügung. Natürlich unterstützt GEFEG.FX den neuen Standard vollumfänglich, kann jedoch zusätzlich auch das Swagger 2.0 Format exportieren.

Was macht GEFEG.FX anders?

Die Stärke von GEFEG.FX liegt in der Design-Time Unterstützung für den elektronischen Datenaustausch. Governance ist heute in aller Munde – und bei GEFEG.FX schon seit Jahrzehnten Standard. So können Datenmodelle oder eine Nachricht natürlich von Grund auf neu entwickelt werden. Darüber hinaus können auch bestehende Standards verwendet oder importiert werden. Transparent auf das jeweilige Profil zugeschnitten oder gegenseitig aufeinander gemappt, ergibt sich ein wesentlicher Vorteil bei der Verwendung von GEFEG.FX. Es wird einfach und sofort ersichtlich, ob und wo Lücken bestehen oder welche Besonderheiten die jeweilige Umsetzung erfordert. Diese Stärke überträgt GEFEG.FX auf die Welt der APIs.

Wie kann ich denn nun meine Datenmodelle in APIs wiederverwenden?

Auch bei APIs kann auf bereits existierende Standards zurückgegriffen werden. So können bereits bestehende APIs im OpenAPI oder Swagger-Format einfach nach GEFEG.FX importiert werden. Entweder direkt oder mittels GIT- und SVN-Unterstützung.

Darüber hinaus können jedoch auch die UML-Datenmodelle oder die Referenzdatenmodelle der UN/CEFACT sowie jedes beliebige XML-Format verwendet werden, um daraus eine API zu definieren. Und das Besondere: Die Verbindung bleibt erhalten. Wird das zugrundeliegende Datenmodell oder die verknüpfte Nachrichtenstruktur aktualisiert, kann sich das auf Wunsch direkt auf die API auswirken.

Eine zentrale Stelle für die Wartung von Datenmodellen, XML und API

Dies bedeutet insbesondere, dass mit GEFEG.FX effektiv mehrgleisig gefahren werden kann. Ergibt sich ein Änderungsbedarf der elektronischen Anbindung der Geschäftspartner, müssen nicht mehr jedes Mapping und jedes Profil einzeln angepasst werden. Die Anpassung kann zentral vorgenommen werden und wirkt sich unmittelbar auf die Datenmodelle, XML-Nachrichten und die API-Spezifikation aus. So einfach kann die Umsetzung von Compliance-Anforderungen sein.

Einsatz und Vorteile von APIs und EDI in Datenaustauschprozessen in der Supply Chain

In der Welt von EDI spielen branchenspezifische Standards eine wesentliche Rolle. Die möglichst gleichförmigen Implementierungen zum Austausch von Geschäftsprozessen machen die Systeme stabil, aber auch träge. Im Gegensatz dazu ermöglichen APIs Supply-Chain-Management in Echtzeit – transparent und steuerbar. Eine flächendeckende, organisations- oder sogar branchenübergreifende Implementierung scheitert jedoch häufig an fehlenden Standards. Dennoch gelten APIs als der Weg der Zukunft. Manche sagen EDI schon ein baldiges Ende voraus. Aber ist das wirklich der Fall? Nach Abwägen der Vor- und Nachteile sind APIs die Zukunft des Datenaustauschs. Sie werden in Zukunft besonders zeitkritische EDI-Prozesse ablösen. EDI bleibt bei etablierten Prozessen bestehen.

APIs im Supply Chain Management – Läuten APIs das Ende von EDI ein?

Supply-Chain-Management hat sich Mitte der 1990er Jahre in Deutschland etabliert. Es steht für die Überwindung interner und externer Unternehmensgrenzen. Der ganzheitliche Ansatz konzentriert sich auf die Steuerung und Verbesserung sämtlicher Produktionsschritte. Beginnend bei der Planung über die Beschaffung und Produktion bis hin zur Distribution werden alle Schritte des Datenaustauschs abgedeckt. Dies umfasst darüber hinaus auch Aktivitäten, die nicht im Einflussbereich eines einzelnen Unternehmens liegen.

Der Schlüssel zum Erfolg liegt in einem funktionierenden, automatisierbaren Informationsfluss. Hierfür werden Geschäftsprozesse wie Bestellung oder Rechnungserstellung digital abgebildt. Aber auch zeitkritische Prozesse, wie sie bei der Just-in-Time Produktion auftreten, werden (teil-) automatisiert durchgeführt. Was in der Theorie hervorragend klingt, stößt in der Praxis häufig an Grenzen. Gängige EDI-Standards stammen auch in den 2020er Jahren noch von Standards aus den 1990er Jahren ab. Und das, obwohl es längst schon aktuellere Versionen gibt. Neben dem Prinzip „Never-touch-a-running-system“ kommt noch hinzu, dass die EDI-Standards viele Optionen zulassen. In der Praxis führt ein solch offener Standard also zu einer Vielzahl von mehr oder weniger stark von einander abweichenden Implementierungen. Darüber ist sicherzustellen, dass alle am Datenaustausch beteiligten Partner dieselbe Variante eines Standards umsetzen. Somit werden Standards in der Praxis zu Anwendungsempfehlungen degradiert.

Der Datenaustausch selbst erfolgt Dokumenten- bzw. Nachrichtenorientiert. Dies bedeutet, dass selbst bei kleinen Änderungen am Geschäftsprozess, die gesamte Nachricht mit allen beteiligten Partnern abgestimmt und von allen zum gleichen Stichtag umgesetzt werden muss.

APIs werden von vielen Seiten als Ausweg aus diesem Dilemma gesehen. Auch wenn APIs genutzt werden könnten, dieselben Nachrichten von A nach B zu transportieren, ist das jedoch nicht die dahinter stehende Idee. Vielmehr ermöglichen Sie durch das Aufbrechen der Dokumenten- und Nachrichtenstrukturen eine einfachere Durchführung dieser und gänzlich neuer Geschäftsprozesse. Supply-Chain-Management in Echtzeit mit APIs ist das ausgerufene Ziel. Läuten APIs also das Ende von EDI ein? Ein klares Jein.

APIs die Treiber von Interkonnektivität

APIs sind das elektronische Bindegewebe unserer heutigen globalen Welt. Sie sind in mittlerweile in fast jedem Stück Software enthalten, das mit anderer Software zum Beispiel über das Internet kommuniziert. Als Mittel zur B2B Datenübertragung sind sie jedoch recht neu. Für Unternehmen bringen sie Kostenvorteile, Effizienzsteigerungen und eine erhöhte Servicequalität. Sie verbessern bestehende oder ermöglichen sogar die Implementierung neuer Geschäftsprozesse. Nicht umsonst hat eine Studie von McKinsey das zu erwartende Gewinnpotenzial von APIs auf eine Billion US-Dollar beziffert.

Mithilfe einer sinnvoll designten API können voneinander unabhängige Systeme miteinander kommunizieren. Die API „liegt“ quasi zwischen den beiden Systemen. Sie schlägt die Brücke zwischen den Systemen und spezifiziert Format und Art der Datenübertragung. Doch das kann EDI ebenfalls. Spannend wird es, wenn APIs Teil der Geschäftslogik sind. Zum Beispiel dienen sie nicht ausschließlich zum Datentransport, sondern übernehmen auch Serviceaufgaben. So benachrichtigen sie beispielsweise ein System, wenn in einem anderen System bestimmte Bedingungen erfüllt sind. Die meisten kennen das, wenn sie in einem Onlineshop etwas bestellt haben. Sie bekommen automatisch eine Nachricht, wenn die Zustellung des Pakets nicht mehr weit in der Zukunft liegt. Bei richtiger Implementierung bieten sie gegenüber EDI einen weiteren entscheidenden Vorteil: Supply-Chain-Management in Echtzeit mit APIs.

Supply-Chain-Management in Echtzeit mit APIs

Dieser Aspekt eröffnet Unternehmen die Möglichkeit, noch enger miteinander zu kooperieren. Informationen werden schneller über mehrere Stufen der Supply Chain weitergegeben. Große Logistikdienstleister nutzen oftmals sogar mehrere APIs, um ihr Warehouse Management zu verbessern. Über die Inventory Management API werden die Systeme der B2B-Kunden in Echtzeit über den aktuellen Lagerbestand eines bestimmten Produktes oder über freie Lieferkapazitäten informiert. Kunden können somit Lagerbestände direkt in einem Webshop in Echtzeit anzeigen.

Über solche APIs können Bestellrhythmen und Prozessketten präziser gemanagt werden. Gegenüber anderen Marktteilnehmern bietet das entscheidende Wettbewerbsvorteile. Damit eine API erfolgreich eingesetzt werden kann, sind jedoch einige Voraussetzungen zu beachten.

Hürden in der API-Entwicklung

Bei der Spezifikation einer API muss zunächst definiert werden, was die API leisten soll. Welcher genaue Service soll erbracht werden? Mit welchen bestehenden Systemen soll sie interagieren? Soll die API frei zugänglich sein oder nur für einen geschlossenen Teilnehmerkreis? Wie viele Abfragen der API werden erwartet? Und nicht zuletzt: Welches Geschäftsmodell soll die API finanzieren? Vor allem die ersten beiden Punkte müssen für Außenstehende nachvollziehbar gemacht werden, damit sie die API verstehen und richtig benutzen können. Darüber hinaus sind auch datenschutzrechtliche Aspekte zu bedenken, um einen Missbrauch der API zu vermeiden. Nicht zu vergessen, dass darüber hinaus intensive Test- und Iterationsphasen anfallen. Doch lohnt sich der Aufwand und kann ein KMU so etwas überhaupt leisten?

Ja, denn die Hürden aus Entwicklersicht sind wesentlich geringer als in der EDI-Welt. EDI-Entwicklung benötigt in der Regel Spezialisten oder die entsprechenden Dienstleister. Je weiter weg die Partner von den etablierten EDI-Märkten sind, desto schwieriger ist es, das benötigte Wissen und die erforderliche Erfahrung zu finden. Heutige Entwickler sind jedoch rund um den Globus mit APIs aufgewachsen. Denn die aktuellen APIs kommen urprünglich aus der Bereitstellung von Services auf mobilen Geräten. Die fängt bei Kartendarstellungen und Navigation an und geht bis hin zu automatischen Übersetzer-APIs die Videos mit automatisch generierten Untertiteln versehen.

Auch die Spezifikation von APIs ist vergleichsweise einfach. Insbesondere dann, wenn die eingesetzten Tools es ermöglichen, die bestehenden Datenstrukturen weiter zu verwenden.

EDI ein Auslaufmodell?

EDI ist nach wie vor der etablierte Ansatz zur Übertragung strukturierter geschäftsrelevanter Daten im B2B-Umfeld. Für eine positive Zukunft von EDI sprechen mehrere Aspekte. Die zwischen den Unternehmen eingerichteten Verbindungen bestehen bereits lange Jahre. Innerhalb der Branche haben sich bestimmte EDI-Standards etabliert. Sich nicht an diese Standards zu halten bedeutet in der Regel, die etablierten Verträge anpassen zu müssen. Erfolgreiche EDI-Projekte dienen als Referenz. Ihre Datenstrukturen bilden die Blaupause für weitere Implementierungen. Auch für den Datenaustausch zwischen den Branchen haben sich durch Konverter-Software und Mappings harmonisierte EDI-Workflows entwickelt. Durch die jahrelange Arbeit wissen Entwickler und Supporter worauf sie bei der Behebung von Fehlern oder dem Aufbau einer neuen EDI-Verbindung zu achten haben. Vielfach wird EDI von Unternehmen als sehr zuverlässig angesehen, weil sie denselben Nachrichtenstandard schon seit den 1990er Jahren verwenden. Never change a running system ist hier die Devise.

Gegen EDI spricht die geringere Flexibilität und Skalierbarkeit. APIs sind von ihrem Grunddesign darauf ausgelegt in ihrer Funktionalität flexibel zu sein und von wechselnd vielen Usern gleichzeitig verwendet zu werden. Dabei übermitteln sie nur den konkret benötigten Teil an Informationen. EDI-Nachrichten hingegen können so umfangreich sein, dass eine Übermittlung von akualisierten Informationen in einem kleineren Zeitfenster als 15 bis 30 Minuten technisch kaum zu realisieren ist. Die Fokussierung auf den Austausch von Geschäftsdokumenten bringt hohe Wartungs- und Pflegekosten mit sich.

Anders als beim Einsatz von APIs erhält der Absender beim Versenden einer EDI-Nachricht nicht standardmäßig sofort eine Eingangsbestätigung oder eine Rückmeldung. Natürlich lässt sich so etwas auch mit EDI realisieren. Jedoch bedeutet dies die Implementierung zusätzlicher (Rück-)Nachrichten.

Ist also die API die Lösung schlechthin?

Heutzutage werden oftmals die Vorteile von API durch die Notwendigkeit einer stärkeren Zusammenarbeit zur Erreichung von Kommunikationsstandards wieder aufgehoben. Anstatt einheitliche Datenstrukturen wie in EDI-Prozessen wiederzuverwenden, werden APIs unternehmensspezifisch implementiert. Dies fällt besonders ins Gewicht, wenn neue Handelspartner angebunden werden. Oftmals geben die größeren Partner ihren Lieferanten oder Kunden die zu verwendenden APIs vor. Spätestens jedoch, wenn es zu einer branchen- oder prozessübergreifenden Kommunikation kommen soll, entstehen große Inkompatibilitätshürden. Doch genau an dem Punkt machen Initiativen, wie sie derzeit von großen Standardisierungsorganisationen betrieben werden, Hoffnung.

Das klare Jein zu EDI

Als „alte“ Grundlagentechnologie funktioniert EDI gut, aber es hat auch seine Grenzen. Für funktionierende Prozesse eine neue Technologie einzuführen bedeutet für Unternehmen, Mitarbeiter aus dem Tagesgeschäft abzuziehen und damit einen Rückgang der Leistungsfähigkeit des Unternehmens zu riskieren. Mit diesem Wissen im Hintergrund scheint es recht unwahrscheinlich, dass Unternehmen (kurzfristig) EDI vollständig ablösen. Etablierte EDI-Prozesse sind oft unternehmenskritisch. Sie bleiben bestehen, wenn es keinen zwingenden Grund zur Ablösung gibt. APIs sind die Zukunft des Datenaustauschs. Auf absehbare Zeit sind sie jedoch ergänzend zu EDI zu betrachten. Sie werden insbesondere dann frühzeitig eingeführt, wenn besonders zeitkritische Prozesse zu optimieren sind. Somit ist Supply-Chain-Management in Echtzeit mit APIs ein realistischer Ansatz. Eine vollständige Ablösung von EDI jedoch nicht.

Die OpenAPI Initiative hat gerade die Version OpenAPI 3.1 veröffentlicht. Am 17.02.2021 stellten Ron Ratovsky von SmartBear und Darrel Miller von Microsoft die neue Version vor. Dieser Artikel beschäftigt sich mit der Frage, was OpenAPI 3.1 Neues mit sich bringt und was das für bestehende Umsetzungen bedeutet.

Wer mehr zum Spezifikationsstandard OpenAPI an sich erfahren möchte, kann gerne auf der offiziellen Webseite oder in dem Artikel „Mit OpenAPI sieht so für mich die Zukunft aus: Eine Welt ohne Geschäftsdokumente. Model-First mit GEFEG.FX“ nachlesen.

Die wesentlichen Änderungen von OpenAPI 3.1

Unterstützung von Webhooks

Aus meiner persönlichen Sicht ist der größte Unterschied die Unterstützung von Webhooks in APIs. Da das Thema für viele neu ist, habe ich noch einen kleinen Artikel zum Thema „Kein Haken an Webhooks. Jetzt flexible APIs bauen mit OpenAPI 3.1 und GEFEG.FX“ verfasst. Dort findet sich auch ein Beispiel. Webhooks sind ein wesentlicher Erfolgsfaktor von WordPress. Erst diese Technik ermöglicht es Anwendungen effizient zu schreiben, und sie über Plug-ins einfach und standardisiert zu erweitern. Auch die OpenAPI Initiative hat Webhooks als so wesentlich angesehen, dass sie ein neuer Dokumententyp in OpenAPI sind. Eine OpenAPI Spezifikation hat somit nun drei grundlegende Wurzelelemente: Paths, Components und Webhooks.

Es kann nun also eine gültige API-Spezifikation geben, die ausschließlich Webhooks definiert. Auf den ersten Blick mag das seltsam erscheinen. Doch das kann etwas sehr Nützliches sein. Anwendungen sind schneller API-fähig, insbesondere, wenn sie einen festen Prozessablauf haben. Auch können damit nun bestehende APIs von Anwendungen wie WordPress sauber spezifiziert werden.

Bei der Spezifikation eines Webhooks wird der Pfad (Endpunkt) definiert, der in der fremden API ausgeführt wird. Im Gegensatz zu einem Callback ist ein Webhook also eine aktive Aktion in der fremden API. Schreibt mir doch mal in die Kommentare, was Ihr von den neuen Webhooks haltet.

Im Rahmen der Erprobung der Webhooks ergab sich schnell der Bedarf, auch Pfade wiederverwendbar zu machen, was zu der nächsten Änderung führt.

Globale Pfaddefinitionen

Mit der Version OpenAPI 3.1 können nun auch Pfade unter den Components spezifiziert werden. Ähnlich wie bei den Parametern kann einem Pfad nun ein global verfügbarer Name zugeordnet werden. Dies ist ein wesentlicher Schritt zur Standardisierung und besserer Governance von API – Implementationen.

Referenzierte Objekte mit überschriebener Beschreibung

Gerade bei der Definition globaler Objekte oder globaler Datenstrukturen kommt man häufig zu der Situation, dass in der konkreten Anwendung der Struktur sich der betriebswirtschaftliche Begriff ändert.

Hierzu ein einfaches Beispiel: Sagen wir mal, wir haben ein generisches Schema-Objekt definiert, mit der wir eine Anschrift bestehend aus Straße, Postfach, Postleitzahl, Ort und Land abbilden können. Und nun wollen wir diese Anschrift an verschiedenen Stellen nutzen. Bereits bei einer Organisation kann es aber mehr als eine Anschrift geben. Aus rein postalischer Sicht kann eine Organisation in Deutschland eine Hausanschrift, eine Postfachanschrift oder eine Großkundenanschrift haben. Kommen dann noch logistische Überlegungen hinzu, so können zum Beispiel noch Informationen zu Toren, Filialen oder ähnlichem hinzukommen.

OpenAPI 3.1 erlaubt nun bei der Referenz auf ein Schemaobjekt, die Summary und die Description zu überschreiben. Somit können nun also diese verschiedenen Ausprägungen der Anschrift klar beschrieben werden.

Was OpenAPI 3.1 nicht kann, aber die Lösung mit GEFEG.FX

OpenAPI 3.1 unterstützt lediglich das Überschreiben der verbalen Beschreibung einer Referenz. Insbesondere Wiederholhäufigkeiten oder (einschränkende) Änderungen an der referenzierten Struktur sind jedoch nicht möglich.

GEFEG.FX kann das. So ist es im obigen Beispiel nicht möglich, die Struktur einer Haus-, Postfach- und Großkundenanschrift zu unterscheiden. In OpenAPI 3.1 wären dafür drei verschiedene Schemaobjekte bzw. die Verwendung einer OneOf – Struktur erforderlich. Mit GEFEG.FX kann jedoch direkt an der Referenz definiert werden, dass die Großkundenanschrift zum Beispiel nur aus Postleitzahl, Ort und Land besteht.

Bei einer Hausanschrift wird das Postfach als
Mit GEFEG.FX einfach die Wiederholhäufigkeiten überschreiben

Unterstützung von Rollen und Claims Security

Mit der Version 3.1 werden durchgängig Rollen bei der Spezifikation von security requirements unterstützt. Das vereinfacht die Rechteverwaltung wesentlich. So kann nun zum Beispiel einfach definiert werden, dass schreibende oder löschende Operationen eine andere Rolle benötigen, als der lesende Zugriff.

Description und neue Summaries

Zur Beschreibung von Objekten eines APIs existieren nun neben der description auch noch eine kurze summary. Der wesentliche Unterschied besteht darin, dass die description eine Markdown-Formatierung unterstützt und somit für ausführliche Beschreibungen für den Entwickler ideal geeignet ist. Die summary unterstützt dies hingegen nicht. Sie dient als kurze Zusammenfassung der Funktion des Objektes. Idealerweise kann es somit von Code-Generation-Tools verwendet werden, die Sourcecode direkt aus der OpenAPI 3.1 Spezifikation erzeugen. Die summary könnte zum Beispiel als Kommentar in den Quellcode übernommen werden.

Volle Unterstützung von JSON Schema

Die Version OpenAPI 3.0.x bildet sowohl eine Untermenge von JSON Schema, als auch eine Obermenge von JSON Schema. Das wurde nun behoben. OpenAPI 3.1 ist nun vollständig kompatibel mit JSON Schema.

Weniger Formatangaben bei Datentypen

OpenAPI 3.0.x hat eine ganze Reihe unterstützter Formatangaben bei Datentypen definiert. Das hat sich mit der Version OpenAPI 3.1 geändert. Die Formatangaben gingen teilweise über die JSON Schema Spezifikation hinaus bzw. wiederholten bereits dort definierte Formatangaben.

Durch die Annäherung an JSON Schema werden nun nur noch diejenigen Formate spezifiziert, die das JSON Schema erweitern. Gleichzeitig wurde die Angabe eines Formates als Einschränkung des Datentyps aufgehoben. Die Angabe eines Formates ist nun also mehr eine Annotation, als eine Einschränkung. Die Prüfung ist also durch die jeweilige Applikation vorzunehmen.

Foto von Andreas Pelekies

Was denkt Ihr darüber? Ist das sinnvoll, oder verkompliziert es die Umsetzung eher?
Ich würde mich über eine Diskussion freuen.

 

In OpenAPI 3.1 sind nur noch die Formatangaben spezifiziert, die von JSON Schema standardmäßig nicht unterstützt werden.
Wegen JSON Schema werden nicht mehr alle Formaterweiterungen spezifiziert

Weitere Änderungen mit OpenAPI 3.1

 

Darüber hinaus gibt es noch ein paar weitere Änderungen in OpenAPI 3.1, die ich hier nur stichpunktartig zusammenfassen möchte:

 

  • Unterstützung von Multipart/form data für Parameter
  • Ein Path-Parameter muss auch definiert sein. Dies ist eigentlich logisch, war bisher aber nicht explizit vorgeschrieben.
  • Alle HTTP Methoden unterstützen Request Bodies. Also auch bei DELETE, GET, POST.
  • Dafür sind nun aber Responses optional. Wird eine Spezifikation in einem „Design-First“ Ansatz entwickelt kann es sinnvoll sein, diese erst zu einem späteren Zeitpunkt zu spezifizieren. Gerade in einer kollaborativen Umgebung können somit gültige Spezifikationen ausgetauscht werden, die keine Fantasiewerte für Responses benötigen, da diese vielleicht noch nicht endgültig festgelegt sind.
  • Bei der Angabe von Mediatypes kann nun auch das contentEncoding angegeben werden.

 

Die vollständige Vorstellung des OpenAPI 3.1 Formats (in englischer Sprache) habe ich Euch einmal hier verlinkt.

 

Was bedeutet das für die Umsetzung?

 

Wenn ich mir die Änderungen im Vergleich zur Vorgängerversion anschaue, kann ich schon verstehen, warum die OpenAPI Initiative lange darüber nachgedacht hat, ob es OpenAPI 3.1 oder nicht doch lieber OpenAPI 4.0 heißen soll.

 

Auf der anderen Seite sind doch die meisten Neuerungen kompatibel. Eine API mit einer Spezifikation auf Basis von Version 3.0.x, funktioniert weiterhin. Lediglich die Abwärtskompatibilität ist nicht mehr unbedingt gewährleistet. Das die Vorgängerversion noch keine Webhooks und globale Pfade kannte, ist klar. Probleme würde es aber auch geben, wenn die nun optionalen Responses weggelassen würden. Eine solche Spezifikation wäre in der Vorgängerversion kein gültiges Dokument gewesen. Doch diese Konstellation sollte in den wenigsten Fällen auftreten.

Zum Thema OpenAPI gibt es eine ganze Reihe Artikel und Seiten im Netz. Warum sollte ich also einen weiteren schreiben? Ganz einfach. Viele dieser Artikel richten sich an (erfahrene) Webentwickler. Was ist aber mit all denjenigen, die sich bisher mit EDI oder dem Austausch von elektronischen Geschäftsnachrichten beschäftigt haben? Dieser kurze Einstieg ist für Euch.

APIs zum Austausch von Geschäftsdokumenten

Eine API als Verbindungsstück zwischen zwei Systemen oder Softwarekomponenten an sich ist nichts Neues. Deren Anwendung für den Austausch von Geschäftsdokumenten aber schon. Für diese Anforderung gibt es seit vielen Jahrzehnten Lösungen für den elektronischen Geschäftsdatenaustausch. Beispiele sind das klassische EDI auf Basis von EDIFACT oder der Austausch von XML-Dateien. Letztere erfährt gerade im Zug der verpflichtenden Einführung elektronischer Rechnungen für öffentliche Auftraggeber eine stärkere Verbreitung.

Doch gerade hier zeigen sich auch die Probleme der bisherigen Lösungen. Klassischer Dokumentenaustausch ist prinzipiell nichts anderes als die digitale Nachbildung der Papierwelt. Also hat sich im Grunde genommen in den letzten 100 Jahren kaum etwas am Grundprinzip geändert. Nur das Übertragungsmedium hat sich geändert: von Papier zu einem von vielen elektronischen Formaten. Das ging so lange gut, wie die zu übertragenden Dokumente nur zwischen zwei Partnern ausgetauscht wurden. Zum Beispiel die Rechnung vom Verkäufer zum Käufer.

Durch die fortschreitende Digitalisierung verbunden mit der Globalisierung steigen jedoch die Anforderungen. Oftmals sind am Austausch der Informationen nicht nur zwei, sondern mehr Partner interessiert, zum Beispiel, wenn Waren grenzüberschreitend transportiert werden sollen. Dann kommen neben den klassischen Partnern auch noch die ein- und die ausführende Zollbehörde, das Transportunternehmen und ggf. noch weitere Partner hinzu. Folglich ist dies eine sehr heterogene Welt in Bezug auf die Technik. Und gleichzeitig steigt die Anforderung nach Transparenz in der Lieferkette. Und die Forderung Produktpiraterie und -fälschungen besser erkennen und verhindern zu können.

Mit klassischem EDI ist das kaum umsetzbar

Doch warum ist das mit klassischem EDI so schwierig umzusetzen? Sicherlich spielt dabei eine wesentliche Rolle, dass es nicht „Das EDI“ gibt, sondern viele verschiedene Standards zum Austausch von Geschäftsdokumenten. Diese sind teilweise durch Anforderungen einer Branche oder individuelle Anforderungen einzelner Unternehmen noch zusätzlich beladen. Dadurch wird ein Standard oftmals so stark verwässert, dass es viele hundert Varianten einer einzelnen Nachricht geben kann. Darüber hinaus kommt noch erschwerend dazu, dass hier die Anforderungen an „Geschäftsdokumente“ erfüllt werden sollen.

Doch diese Anforderungen kommen aus der Papierwelt. Einer Welt, in der Menschen das erhaltene (Papier-) Dokument mit den Büchern (Buchhaltung) abgleichen. Diese Dokumente enthalten außerdem sehr viele Informationen, die in einem elektronischen Prozess eigentlich überflüssig sein könnten.

So braucht zum Beispiel eine Zollbehörde nicht die kompletten Vertragsbeziehungen einschließlich Lieferbedingungen oder vereinbarten Konditionen zu kennen. Klassisch entstehen hierfür wiederum neue Dokumente und neue (EDI -) Nachrichten. Oder beteiligte Personen oder Systeme haben (noch) keinen einheitlichen elektronischen Zugriff auf die Informationen. Heute kündigen große Lieferanten und ihren Kunden Lieferungen elektronisch an (Despatch advice). Und dennoch wird zusätzlich ein Lieferschein oder Warenbegleitschein ausgedruckt und der Sendung beigefügt.

Für eine EDI-Umsetzung müssen also die Prozesse der einzelnen Organisationen entlang der Wertschöpfungsketten auch semantisch ineinandergreifen. Also müssen auch die Managementsysteme der Organisationen mit solchen elektronischen Nachrichten umgehen können. Und immer auf einem gleichen Stand sein. Das ist in der Praxis nur schwer zu erreichen. Standards helfen dabei, aber eine Umsetzung ist oftmals zu schwierig und zu teuer.

Wer cloud meine Daten?

Noch ein weiterer Aspekt kommt hinzu. Eine Studie aus dem Jahr 2020 hat gezeigt, dass eines der größten Hemmnisse die Angst ist, durch zentrale Datenaustauschplattformen die Kontrolle über die eigenen Daten zu verlieren.

Die Sicherung der Datensouveränität ist also ein wesentlicher Aspekt, wenn im Business-to-Business Bereich Plattformen neu geschaffen werden sollen.

REST APIs bieten hier einen klaren Ansatz, sich von den Geschäftsdokumenten für den Datenaustausch zu lösen. Stattdessen werden nur die tatsächlich benötigten Informationen ausgetauscht. Mit klar definierten Partnern. So kann zum Beispiel sichergestellt werden, dass keine vereinbarten Preise über ein Lieferantenportal in die falschen Hände gelangen.

Trennung von Datenstrukturen und Services

Ein klassisches EDI Szenario umfasst im Wesentlichen nur zwei Services. Die Umwandlung von Daten eines Quellsystems in das Datenformat des Zielsystems und die Weiterleitung der Daten an das Zielsystem. Natürlich kann es komplexere Szenarien mit Rückmeldungen geben, die ähnlich wie ein Einschreiben mit Rückschein funktionieren. Aber alles, was darüber hinausgeht, ist eigentlich nicht mehr Bestandteil des eigentlichen EDI-Szenarios. Die Prozesse selbst müssen von den jeweiligen Endsystemen erbracht werden, zum Beispiel wird eine Auftragsbestätigung zu einer Bestellung vom System des Verkäufers erstellt. Die EDI-Lösung überträgt diese dann wiederum zurück. Also wiederum mit denselben Services, jedoch einem anderen Dokument.

In der Welt der APIs geht der Servicegedanke darüber hinaus. Eine API kann aktiv einzelne Prozessschritte unterstützen. Oder sie kann auch echten Mehrwert bieten, wie zum Beispiel die Bereitstellung von Informationen, wobei der API-Nutzer festlegen kann, welche Filterkriterien dabei angewendet werden sollen. Dies ist in der klassischen EDI-Welt kaum denkbar.

Diese Möglichkeiten führen dazu, dass in einer API nicht nur die Datenstrukturen definiert sind, sondern auch die Services. Diese verwenden dann die definierten Datenstrukturen, um eingehende Informationen zu verarbeiten, oder ausgehende Informationen bereitzustellen.

Machen APIs nicht alles komplizierter?

Puh, das klingt ziemlich kompliziert. Und wenn jetzt noch mehr dazu kommt, wird es dann nicht noch unübersichtlicher? Und irgendjemand muss es ja auch noch implementieren!

Genau hier setzt OpenAPI an. Gerade keine proprietären Regeln zu entwickeln, sondern die Spezifikation einer API zu standardisieren. Diesen Unterschied zu verstehen, ist immens wichtig. Es geht also nicht darum, wie eine API implementiert wird. Nein, sondern darum, was sie genau leisten soll. Welche Services sie bietet und welche Datenstrukturen sie dabei unterstützt.

Wie oben beschrieben gibt es im EDI-Umfeld viele Standards, auch internationale. Das Zentrum der Vereinten Nationen für Handelserleichterungen und elektronische Geschäftsprozesse UN/CEFACT standardisiert bereits seit vielen Jahren die Bedeutungen von Datenstrukturen bei Geschäftsdokumenten. UN/CEFACT veröffentlicht semantische Referenzdatenmodelle, an denen sich weltweit viele Organisationen und Branchen orientieren.

Von Bedeutungen und Zwillingen

REST APIs werden im Internet bereits viele Jahre eingesetzt. Vor allem zur Bereitstellung von Dienstleistungen für andere Webseiten oder auf mobilen Geräten. Beispiele sind APIs zur Währungsumrechnung oder die diversen Karten-APIs, mit der man einfach von A nach B navigieren kann. Das semantische Web spielt dabei ebenfalls eine wichtige Rolle. Die Systeme der Onlineshops, Suchmaschinen und sozialen Netzwerke sollen semantische Zusammenhänge erkennen können. Zum Beispiel welche Zutaten ein Rezept benötigt, wie lange die Zubereitung dauert, und welche Shops diese Zutaten zu welchen Preisen anbieten.

Eine wesentliche Grundlage dafür bieten die Standards auf schema.org. An diesen klaren Definitionen orientieren sich all diese Dienste und ermöglichen es sogenannte digitale Zwillinge (Digital Twins) abzubilden. Alles Identifizierbare der realen Welt lässt sich auch digital abbilden: Personen, Veranstaltungen, Häuser, Lizenzen, Software, Produkte und Dienstleistungen, um nur einige zu nennen. Und das Ganze verständlich für Menschen und durch Maschinen verarbeitbar.

Kein Wunder also, dass viele sich die Frage gestellt haben, wie sich dies auf die Business-to-Business-Ebene übertragen lässt, auch UN/CEFACT. Wie bleiben die Errungenschaften der letzten Jahrzehnte mit Web-APIs erhalten?

OpenAPI – Ein Spezifikationsstandard für APIs

Der Spezifikationsstandard OpenAPI definiert also ein Regelwerk, wie APIs zu spezifizieren sind. Welche Services werden bereitgestellt? Welche Datenstrukturen werden benötigt? Was sind die Anforderungen an eine Implementierung? Und das Ganze sowohl in einer Version, die durch den Entwickler gelesen werden kann, aber auch durch eine Maschine.

Genau hier liegt die eigentliche Stärke dieses Standards. Der sehr große Support durch eine Vielzahl an Tools und Programmierumgebungen. Damit ist es möglich, eine API auf der Fachebene zu definieren. Mit all ihren Services und Datenstrukturen. Sie kann gleichzeitig beschrieben werden, so dass ein Entwickler diese möglichst intuitiv umsetzen kann.

Und dabei wird der Entwickler massiv unterstützt. Da die Spezifikation maschinenlesbar ist, existieren Tools, die direkt aus der Spezifikation Quellcode erzeugen. Damit ist sichergestellt, dass die spezifizierten Eigenschaften der Schnittstelle selbst korrekt implementiert sind: Die Namen von Endpunkten (Services) sind korrekt. Die von diesen verwendeten Datenstrukturen sind korrekt umgesetzt und auch alle Rückgabewerte klar definiert.

Natürlich muss der Entwickler noch die eigentliche Implementierung der Server- bzw. Clientseite vornehmen. Stellt er sich dabei geschickt an, kann diese Implementierung sogar sicher gegenüber künftigen Änderungen sein. Eine Aktualisierung der Spezifikation kann direkt in den Sourcecode übernommen werden und bedarf nur kleinerer Anpassungen.

Wer definiert OpenAPI?

OpenAPI hat seinen Ursprung in Swagger. Bereits im Jahr 2010 hat der Hersteller von Swagger, die Firma SmartBear erkannt, dass eine API Spezifikation nur dann erfolgreich sein kann, wenn sie offen und gemeinschaftlich (community-driven) entwickelt wird. Daher hat sie die Rechte an die OpenAPI Initiative übertragen. Zu dieser gehören durchaus große Namen wie Google, Microsoft, SAP, Bloomberg und IBM. Diese Community ist sehr aktiv und entwickelt die Spezifikation stetig weiter. Die zum Zeitpunkt dieses Artikels jüngste Veröffentlichung ist OpenAPI 3.1.

Spätestens seit dem Jahr 2016 steht also Swagger nur noch für die von der Firma SmartBear erstellten Tools. Die mit diesen Tools erstellten Spezifikationen sind in der Regel OpenAPI Spezifikationen. Allerdings unterstützten diese Tools auch noch die alten Vorgängerformate, insbesondere das Format Swagger 2.0.

Nutzung und Verbreitung von OpenAPI

Das TMForum führt regelmäßig Studien zur Verbreitung von OpenAPI durch. Die letzte Studie zeigt eine deutliche Zunahme an Adoptionen. Vermehrt umkleiden Unternehmen ihre bestehenden APIs in OpenAPI Spezifikationen, sobald diese zum unternehmensübergreifenden Datenaustausch dienen. Gemäß der Studie teile sich der Markt insbesondere in zwei Lager auf: Klare Vertreter von OpenAPI und solche Organisationen, die sich künftig verstärkt um OpenAPI kümmern wollen.

In der Vorstellung von OpenAPI 3.1 erklärte Darrel Miller von Microsoft, dass es auch noch viele Implementierungen mit RAML gäbe. Jedoch zeige der Trend, dass RAML mehr bei Inhouse-Lösungen zu finden ist. OpenAPI bildet dabei vermehrt die Grundlage für unternehmensübergreifende Szenarien.

Code-First (Swagger) oder Model-First (GEFEG.FX)?

Ein wesentlicher Unterschied bei den derzeit auf dem Markt vorhandenen Tools liegt darin, ob die Quellcodeentwicklung oder die modellbasierte Entwicklung im Vordergrund steht. Der Swagger-Editor ist ein typisches Beispiel für eine Code-First-Anwendung. In einem Editor kann der API-Entwickler direkt seine API-Spezifikation erfassen und dokumentieren. Dies umfasst sowohl die Servicestrukturen, als auch die Datenstrukturen. Neben diesem maschinenlesbaren Format sieht er auch gleich die aufbereitete Dokumentation für einen anderen Entwickler. Die Dokumentation steht dann zum Beispiel in einem Developer-Portal zur Verfügung.

Im Gegensatz dazu verfolgt die Lösung GEFEG.FX einen Modell-getriebenen Ansatz. Nicht der technische Entwickler, sondern der Fachanwender steht hier im Vordergrund. Er ist verantwortlich für die betriebswirtschaftliche Sicht und die Prozesse in der Organisation oder zwischen den Organisationen. Oftmals ist er mit den bestehenden EDI-Implementierungen vertraut, oder er kennt zumindest die (wirtschaftlichen und rechtlichen) Anforderungen an die umzusetzenden Prozesse. Mit diesem Wissen ist er in der Lage die vorhandenen semantischen Referenzmodelle und Standards bei der API-Spezifikation zu verwenden. Das Rad wird nicht jedes Mal neu erfunden. Ändert sich ein solcher Standard, übernimmt GEFEG.FX die Änderung einfach in die API-Spezifikation. Zeitgleich werden die Governance-Anforderungen smart umgesetzt, ohne die einzelnen Abteilungen zu sehr einzuschränken. Dafür spielt es keine Rolle, ob es um die Umsetzung der elektronischen Rechnung, des elektronischen Lieferscheins, EDI, die Konsumgüterindustrie, die Automobilindustrie, die Branche der Energieversorger, UN/CEFACT oder andere geht.

Meine Empfehlung

Der Code-First Ansatz ist perfekt für Web-Entwickler. Fachanwender sind damit aber überfordert. Daher gibt es von mir die klare Empfehlung an all diejenigen mit Schwerpunkt EDI oder dem Austausch von elektronischen Geschäftsnachrichten: Plant OpenAPI als Model-First-Ansatz. Das ist zukunftssicher, erweiterbar und anpassbar.

Die seit OpenAPI 3.1 unterstützten Webhooks definieren klare Punkte in einem Prozess, an denen andere APIs auf klar definierte Art und Weise Operationen ausführen. Die Besonderheit bei Webhooks besteht darin, dass sie – im Gegensatz zu Callbacks – synchron zum Prozess verlaufen. Der Prozess kann die Ergebnisse des Webhooks weiter verarbeiten.

Wozu dienen Webhooks bei OpenAPI 3.1?

Webhooks sind in Internetanwendungen eigentlich nichts Besonderes. Das Geheimnis des Erfolges von WordPress liegt unter anderem in der tiefen Integration von Webhooks in der gesamten Anwendung. Erst durch diese Technik ist WordPress in der Lage, so flexibel um Plug-ins erweitert zu werden.

Prinzipielle Verwendung von Webhooks bei WordPress

Eine Webseite besteht sowohl technisch als auch optisch aus mehreren Bereichen. Sie hat zumindest einen Kopfbereich, oftmals einen Menübereich, einen Inhaltsbereich und einen Fußbereich.

Eine Webseite besteht ist in mehrere Bereiche aufgeteilt. Oben ein Bereich
Beispielhafter Aufbau einer Webseite

Die Ausgabe einer solchen Webseite ist also ein in WordPress klar definierter Prozess. Und dieser Prozess besteht aus mehreren Schritten. Vor, während oder nach jedem dieser Schritte hat WordPress Punkte definiert, in die sich Plug-ins einhaken können, die sogenannten Webhooks.

Das Bild ist in zwei Bereiche aufgeteilt: Links
Beispiel zur Verwendung von Webhooks bei Plug-ins in WordPress

In dem hier gezeigten, vereinfachten Beispiel erweitert das Plug-in das Menü der Webseite. Zusätzlich ersetzt es einen Block auf einer Seite durch die entsprechende Ausgabe. Die Besonderheit ist also, dass das Plug-in die Verarbeitung der Daten im Hauptprozess von WordPress beeinflusst.

Webhooks bei OpenAPI 3.1 sind also so etwas wie Callbacks, nur anders

Bei OpenAPI 3.1 werden natürlich weiterhin Callbacks unterstützt. Heutzutage setzt man Callbacks insbesondere bei ereignisgesteuertem Management ein. Der API Consumer kann einen Callback abonnieren (Subskription). Dabei teilt er dem Callback die Adresse für die Benachrichtigung mit. Dies ist in der Regel wieder ein API-Endpunkt. Es könnte jedoch, je nach Implementierung, auch eine E-Mail-Adresse sein. Manche Callbacks unterstützen zum Zeitpunkt der Subskription noch die Übergabe bestimmter (Filter-) Parameter.

Callback-Beispiel im Online-Handel

Ein typisches Praxisbeispiel für so eine Art von Anwendung haben wir alle schon einmal erlebt: Wir haben etwas bei einem Onlinehändler bestellt. Und dieser versendet das Paket. Wir bekommen (spätestens) am Tag der Lieferung mitgeteilt, dass das Paket bald eintreffen wird. Manche Anbieter gehen nun aber so weit, dass sie Mitteilungen versenden wie „Der Fahrer ist noch 5 Stopps entfernt“. Was ist hier passiert?

Im Prinzip wurde ein Callback eingerichtet, bei dem ein Geofence um die Zieladresse (hier 5 Stopps) mit angegeben wurde. Bei Erreichen der Ereignisbedingung führt der API-Provider den Callback aus und wir erhalten die entsprechende Nachricht. Und nun können wir selbst aktiv werden, müssen es aber nicht. Manche dieser Anwendungen erlauben nun in Echtzeit die Position des Lieferwagens auf einer Karte nachzuverfolgen. Dazu müssen wir aber aktiv diese Anwendung aufrufen. Tun wir das nicht, hat es keinerlei Einfluss auf den Lieferprozess. Sollten wir nicht anwesend sein und auch keine Ablagenehmigung erteilt haben, tritt erst dann im Lieferprozess eine Ausnahmebehandlung (Papiernachricht in Briefkasten einwerfen) ein.

Das Bild ist in zwei Bereiche

Dieses Design hat in Bezug auf die Implementierung des API Consumers einen entscheidenden Nachteil. Es bedeutet, dass hier eine zweite, vollständige API erstellt werden muss. Der Consumer benötigt zum einen den Endpunkt für den Aufruf durch den Callback. Dazu muss eine sichere Verbindung vom API Provider zum API Consumer hergestellt werden. Zum anderen benötigt er für die weiteren Aufrufe noch zusätzlich eine gesicherte Verbindung in umgekehrter Richtung. Die beiden APIs müssen sich also gegenseitig vertrauen und die jeweiligen gegenüberliegenden Schnittstellen unterstützen. Der Callback an sich verhält sich jedoch passiv.

Aktive Ereignissteuerung über Webhooks ab OpenAPI 3.1

Setzt man statt Callbacks nun Webhooks ein, könnte das Szenario etwas anders aussehen. Gerade bei Just-In-Time Lieferungen kommt es darauf an, den richtigen Artikel zum richtigen Zeitpunkt am richtigen Ort zu haben. Oftmals sind aber auf einem Lkw mehrere Artikel geladen, die zu zeitlich nahen Punkten der Fertigung gebraucht werden. Ein Transportunternehmer hat ein recht enges Zeitfenster, in dem er an der jeweiligen Rampe seine Ware anzuliefern hat.

In der Praxis ist dies oftmals schwierig – trotz der langen Erfahrung und der hohen Automatisierung. An welche Rampe fährt der Fahrer denn nun zuerst, wenn er an der Schranke zum Betriebsgelände steht? Hier ist in dem Prozess „Anlieferung“ also eine synchrone Entscheidung gefragt. Der Prozess muss unterbrochen werden und kann erst fortgesetzt werden, wenn die erforderlichen Daten vorliegen.

Das Bild ist vertikal in zwei Bereiche
Webhooks mit OpenAPI 3.1 unterbrechen in der Regel einen Prozess

Der Serviceprozess des API Providers wird durch den Webhook unterbrochen. Der Webhook führt eine Aktion beim API Consumer durch. Die Ergebnisse dieser Aktion können dann im Service des API Providers weiterverarbeitet werden.

Diese Rückgabe ist eine schöne Sache. Aber nicht zwingend erforderlich. Es ist ebenfalls denkbar Webhooks zu definieren, die lediglich eine positive Rückmeldung erwarten, z. B.:200 OK.

Nichts als Webhooks in der API

Eine wesentliche Neuerung bei Webhooks mit OpenAPI 3.1 besteht nun darin, dass APIs spezifiziert werden können, die ausschließlich aus Webhooks bestehen. Als ich das erste Mal davon gehört habe, empfand ich das als merkwürdig. Beim weiteren Nachdenken macht das aber durchaus Sinn.

So lassen sich zum Beispiel APIs spezifizieren, die rein der Prozessüberwachung dienen. Dies ist in etwa vergleichbar mit der Steuerzentrale eines Kraftwerks. Der eigentliche Betrieb erfolgt vollautomatisch. Klar definierte Ereignisse werden auf den Instrumenten der Steuerzentrale angezeigt. Die Bediener haben die Möglichkeit steuernd auf die einzelnen Ereignisse zu reagieren.

Ein weiterer Ansatz wäre die Definition von APIs, die ein ähnliches Konzept wie WordPress verfolgen. Der API Provider führt einen oder mehrere klar definierte Prozesse aus. Zum Beispiel die Kalkulation einer Rechnung, das Buchen eines Tickets oder die Produktion von Waren. In diesem Prozess werden Erweiterungspunkte definiert, vergleichbar mit Extension-Points in XML-Nachrichten. Und an diese Erweiterungspunkte können sich andere APIs einhaken, um die Basisfunktion dynamisch und flexibel zu erweitern.

Nehmen wir einmal an, wir haben eine API geschrieben, die sehr einfache Rechnungen kalkulieren und erstellen kann. Sehr einfach bedeutet hier, dass sie nur einen Verkäufer, einen Käufer und einfache Artikelpositionen unterstützt. Wenn in diesem Prozess an den richtigen Schritten Webhooks definiert sind, kann dieser Prozess einfach erweitert werden. Ein Plug-in könnte zum Beispiel die Berücksichtigung von Rabatten hinzufügen. Ein weiteres Plug-in die Unterstützung von Rechnungen in einer Fremdwährung.

Der geschickte Einsatz von Webhooks macht’s

Und genau hier liegt auch wieder die Schwierigkeit, aber zugleich eine mächtige Chance. Wenn ich auch die Plug-in API so spezifiziert habe, dass sie mit zusätzlichen APIs umgehen kann oder sogar selbst wieder erweitert werden kann, werden aus Webhooks sehr mächtige Werkzeuge.

Genau hier kommt aber der vielleicht entscheidendste Punkt beim Design einer API mit Webhooks. Ich muss den (fremden) APIs vertrauen. Ich muss ihnen zutrauen die Daten für den eigenen Prozess so zu verändern, wie es grundsätzlich vorgesehen ist. Bzw. ich muss auf der API-Provider-Seite berücksichtigen, dass die Daten auf eine Art manipuliert werden, mit der ich ggf. nichts anfangen kann.

Doch dem wirkt andererseits die OpenAPI 3.1 Spezifikation auch wieder entgegen. Denn der API-Provider kann auch die Datenstruktur des Rückgabeformats spezifizieren. Eine Prüfung auf inhaltliche Korrektheit oder Sinnhaftigkeit ist jedoch ggf. noch zusätzlich vorzunehmen. Berücksichtigt der Provider diese Situation nicht oder hat das Plug-in mit der Rabattfunktion einen Fehler, könnte die gesamte Rechnung falsch werden. Zum Beispiel dann, wenn anschließend (scheinbar) auf der Positionsebene steht, dass für einen Artikel, der mit Menge 5 und einem Stückpreis von EUR 4 insgesamt nur EUR 17 zu zahlen sind.

Ein Webhook-Beispiel, erstellt mit GEFEG.FX

Da die offiziellen Webhook Beispiele der OpenAPI Initiative nur sehr dürftig sind, möchte ich abschließend noch ein einfaches Beispiel im YAML-Format aufzeigen.

openapi: 3.1.0
info:
  title: GEFEG CrossIndustryInvoice Webhook example
  version: 1.0.0
webhooks:
  createLineItem:
    post:
      summary: Inform external API that a new LineItem is created
      requestBody:
        description: Information about a new line item in the invoice
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/LineItem'
        required: true
      responses:
        200:
          description: Return a 200 status to indicate that the data was processed successfully. The response body may contain the extended line item.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/LineItem'
  validateLineItem:
    get:
      summary: Validate the LineItem
      requestBody:
        description: Information about the LineItem to be validated
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/LineItem'
        required: true
      responses:
        406:
          description: Not Acceptable, The validation went wrong.
        200:
          description: OK, the line item is valid

components:
  schemas:
    LineItem:
      type: object
      properties:
        AssociatedDocumentLineDocument:
          $ref: '#/components/schemas/DocumentLineDocumentType'
        SpecifiedTradeProduct:
          $ref: '#/components/schemas/TradeProductType'
        SpecifiedLineTradeAgreement:
          $ref: '#/components/schemas/LineTradeAgreementType'
        SpecifiedLineTradeDelivery:
          $ref: '#/components/schemas/LineTradeDeliveryType'
        SpecifiedLineTradeSettlement:
          $ref: '#/components/schemas/LineTradeSettlementType'
      required:
        - AssociatedDocumentLineDocument
        - SpecifiedTradeProduct
        - SpecifiedLineTradeAgreement
        - SpecifiedLineTradeDelivery
        - SpecifiedLineTradeSettlement
    DocumentLineDocumentType:
      type: object
      properties:
        LineID:
          $ref: '#/components/schemas/IDType'
    LineTradeAgreementType:
      type: object
      properties:
        NetPriceProductTradePrice:
          $ref: '#/components/schemas/TradePriceType'
      required:
        - NetPriceProductTradePrice
    LineTradeDeliveryType:
      type: object
      properties:
        BilledQuantity:
          $ref: '#/components/schemas/QuantityType'
      required:
        - BilledQuantity
    LineTradeSettlementType:
      type: object
      properties:
        SpecifiedTradeSettlementLineMonetarySummation:
          $ref: '#/components/schemas/TradeSettlementLineMonetarySummationType'
      required:
        - SpecifiedTradeSettlementLineMonetarySummation
    TradeProductType:
      type: object
      properties:
        Name:
          $ref: '#/components/schemas/TextType'
    IDType:
      type: string
    QuantityType:
      type: number
    TextType:
      type: string
    TradePriceType:
      type: object
      properties:
        ChargeAmount:
          $ref: '#/components/schemas/AmountType'
      required:
        - ChargeAmount
    TradeSettlementLineMonetarySummationType:
      type: object
      properties:
        LineTotalAmount:
          $ref: '#/components/schemas/AmountType'
      required:
        - LineTotalAmount
    AmountType:
      type: number
Code-Sprache: YAML (yaml)

In diesem Beispiel werden zwei Webhooks definiert. Der erste createLineItem wird aufgerufen, wenn eine neue Position eingefügt wird. Der Webhook führt also in der externen API die POST – Operation durch und übergibt dabei die Informationen der aktuellen Position. Als Rückgabe wird wiederum die (ggf. durch Extension) erweiterte Position als Rückgabewert erwartet.

Der zweite Webhook validateLineItem dient dazu, die Validierung der Position erweitern zu können. Die externe API wäre somit in der Lage, zum Beispiel die Rabattberechnung zu prüfen. Stimmt diese, liefert sie den Code200. Ist etwas schiefgegangen, liefert sie den Code406.

Dieses Beispiel ist eventuell noch nicht in allen Belangen ausgereift, soll aber die Möglichkeit zur Anwendung von Webhooks mit OpenAPI 3.1 zeigen.