Was ist ein API-Endpunkt?

APIs und Endpunkte waren schon immer ein heißes Diskussionsthema unter Frontend– und Backend-Entwicklern gleichermaßen. Um nützliche und nachhaltige Anwendungen und Dienste zu entwickeln, sind APIs ein leistungsfähiges Medium und ein Wegbereiter.

APIs erleichtern die Datenübertragung zwischen verschiedenen Software-Artefakten, um Kundenprobleme zu lösen. Fast alle modernen webbasierten Produkte bieten ihre eigenen APIs an, um mit ihren Diensten zu interagieren und sie direkt in jedes Projekt zu integrieren.

Wenn du mit deinen Konkurrenten mithalten und deinen Nutzern ein nahtloses, plattformübergreifendes Erlebnis bieten willst, musst du das Spiel der APIs kennen und beherrschen.

In diesem Leitfaden erfährst du, was ein API-Endpunkt ist, wie du eine öffentlich verfügbare API nutzen kannst und welche Möglichkeiten es gibt, deine API-Endpunkte zu sichern und zu überwachen.

Verständnis von API-Endpunkten

„API“ ist die Abkürzung für „Application Programming Interface“ Es handelt sich im Wesentlichen um eine Reihe von Regeln, die es einer Anwendung ermöglichen, ihre Daten mit anderen Anwendungen auszutauschen. Mit einfachen Worten: Eine API ermöglicht es dir, Daten zwischen deiner Anwendung und einer Drittanbieter-Anwendung auszutauschen.

Ein API-Endpunkt ist ein digitaler Ort, der über die API zugänglich ist und von dem aus die API Anfragen empfängt und Antworten sendet. Jeder Endpunkt ist eine URL (Uniform Resource Locator), die den Standort einer Ressource auf dem API-Server angibt.

Um den Zweck und die Verwendung von APIs zu verstehen, müssen wir zunächst wissen, wie sie funktionieren.

Wie APIs funktionieren

Damit zwei Softwareanwendungen über das Internet kommunizieren können, sendet die eine Anwendung (Client genannt) eine Anfrage an die API-Endpunkte der anderen Anwendung (Server genannt). Je nach den Fähigkeiten der API kann der Client eine Ressource aus einer Datenbank anfordern oder den Server bitten, eine Aktion in seiner Umgebung durchzuführen und die Ergebnisse zurückzugeben.

Nach Erhalt des Ergebnisses vom Client führt die API (oder der Server) die angeforderte Aktion aus und sendet das Ergebnis der Aktion in Form einer Antwort an den Client zurück. Diese Antwort kann auch alle Ressourcen enthalten, die der Kunde angefordert hat.

Es gibt verschiedene Arten von APIs, darunter REST, SOAP und GraphQL. Sie funktionieren alle unterschiedlich, aber ihr Zweck ist immer derselbe: die Kommunikation zwischen webbasierten Einheiten zu erleichtern. In diesem Leitfaden werden wir hauptsächlich über REST-APIs sprechen, da sie weltweit zu den beliebtesten APIs gehören.

Was ist der Unterschied zwischen einer API und einem Endpunkt?

Das bringt uns zu der nächsten und häufigsten Frage: Was ist der Unterschied zwischen einer API und einem Endpunkt?

Eine API ist ein Satz von Protokollen und Werkzeugen, die die Interaktion zwischen zwei Anwendungen erleichtern. Ein Endpunkt ist ein Ort in der API, an dem der Austausch stattfindet. Endpunkte sind URIs (Uniform Resource Identifiers) auf einer API, auf die eine Anwendung zugreifen kann.

Alle APIs haben Endpunkte. Ohne einen Endpunkt wäre es unmöglich, mit einer API zu interagieren.

Wie funktionieren Endpunkte mit APIs?

Um dein Verständnis von APIs und Endpunkten zu vertiefen, wollen wir ein kleines Beispiel aufgreifen.

Nehmen wir die Cat Facts API. Diese API liefert zufällige Katzenfakten. Sie listet aber auch verschiedene Endpunkte auf, über die du kategorisierte Informationen abfragen kannst. Es gibt drei verfügbare Endpunkte:

/fact: Gibt einen einzelnen, zufälligen Katzen-Faktor zurück.
/facts: Liefert eine Liste von zufälligen Katzenfakten.
/breeds: Liefert eine Liste von Katzenrassen.

Um eine Anfrage an diese API zu stellen und eine Katzeninformation abzurufen, musst du den richtigen Endpunkt ( /fact) an die Basis-URL der API ( https://catfact.ninja/) anhängen. So erhältst du die folgende Endpunkt-URL: https://catfact.ninja/fact

Wenn du eine GET Anfrage an die obige URL sendest, erhältst du ein ähnliches Ergebnis:


{
    "fact": "Spanish-Jewish folklore recounts that Adamu2019s first wife, Lilith, became a black vampire cat, sucking the blood from sleeping babies. This may be the root of the superstition that a cat will smother a sleeping baby or suck out the childu2019s breath.",
    "length": 245
}

Du hättest diese Daten nicht erhalten können, wenn du auf einen anderen Endpunkt zugegriffen hättest, z. B. auf /breeds. So helfen Endpunkte dabei, mit den von einer API bereitgestellten Ressourcen zu interagieren und sie zu organisieren – jeder Endpunkt ist spezifisch für einen bestimmten Teil der Daten.

Warum sind API-Endpunkte wichtig?

Der Datentransfer und die gemeinsame Nutzung von Ressourcen gehören zu den Grundpfeilern des Internets. Jeden Tag kommen mehr und mehr Prozesse und Anwendungen zum globalen Netzwerk hinzu, die durch die gemeinsame Nutzung von Dingen einen Mehrwert für das Netzwerk darstellen.

Ohne APIs wäre das alles nicht möglich. APIs bieten ein leistungsstarkes Medium für die Kommunikation und Interaktion zwischen webbasierten Anwendungen.

API-Endpunkte wiederum helfen dabei, den genauen Standort der Ressourcen in der API zu bestimmen. Sie helfen API-Entwicklern dabei, die verfügbaren Ressourcen zu organisieren und den Zugriff der Verbraucher zu kontrollieren. Deshalb hängen die Leistung und Produktivität von Anwendungen, die APIs nutzen, direkt von der Gestaltung und Leistung der API-Endpunkte ab.

Mit bestehenden API-Endpunkten arbeiten

In den meisten Fällen wirst du vorgefertigte APIs nutzen müssen. Damit du das effizient tun kannst, musst du wissen, wie du die Endpunkte findest und dich mit den verschiedenen Versionsregeln der Branche zurechtfindest. In diesem Abschnitt erfährst du, wie das geht.

Einen API-Endpunkt ausfindig machen

Das Auffinden eines API-Endpunkts ist eine einfache Aufgabe, wenn du Zugang zur API-Dokumentation hast. Manchmal sind in der Dokumentation die Endpunkte einfach mit kurzen Beschreibungen aufgeführt. In anderen Fällen (z. B. bei Swagger) kann die Dokumentation komplexer und umfangreicher sein, und du kannst die Endpunkte direkt auf der Dokumentationsseite testen.

In jedem Fall ist es in deinem Interesse, wenn du dir Zeit nimmst, um den Zweck jedes Endpunkts zu verstehen, bevor du ihn einsetzt. So kannst du die meisten Fehler vermeiden und deine Effizienz steigern.

Versionierung von API-Endpunkten

Wie die meisten anderen Software-Artefakte werden auch APIs versioniert. Die Versionierung hilft dabei, die API zu beobachten und zu analysieren, während sie im Entwicklungsprozess wächst. Der Zugriff auf alte Versionen kann dir auch dabei helfen, im Falle eines fehlerhaften Updates auf frühere, stabile Versionen zurückzugreifen. Hier sind einige gängige Methoden, mit denen API-Endpunkte versioniert werden.

URI-Pfad

Eine der beliebtesten Methoden zur Versionierung von API-Endpunkten ist die Aufnahme einer Versionsnummer in den URI-Pfad. So könnte es aussehen:

http://example.com/api/1/resourcename

Du kannst diesen Ansatz als eine Möglichkeit betrachten, die API-Endpunkte global zu versionieren. Wenn du eine Subdomain für deine API verwendest, wie z. B.:

http://api.example.com/resourcename

… kannst du auch einen Versionsindikator in deine Subdomain einfügen, etwa so:

http://api-v2.example.com/resourcename

Wie du siehst, ändert dieser Ansatz die URI-Route der API, sodass sich jede Version wie eine eigenständige Ressource verhält. Das bedeutet, dass du bei Bedarf gleichzeitig auf die beiden Versionen der API zugreifen und sie sogar unabhängig voneinander zwischenspeichern kannst, um einen schnelleren Zugriff zu ermöglichen.

Wenn du eine Versionsnummer in den URI-Pfad (und nicht in die Subdomain) einfügst, kannst du das folgende Format verwenden, um weitere Informationen anzugeben:

MAJOR.MINOR.PATCH

So würde zum Beispiel die interne API aus unserem obigen Beispiel versioniert werden:

http://example.com/api/1.2.3/resourcename

Schauen wir uns nun diese neuen Versionsbegriffe an und erklären, wofür sie jeweils stehen:

MAJOR: Wenn du inkompatible oder bahnbrechende API-Änderungen vornimmst
MINOR: Für das Hinzufügen abwärtskompatibler Funktionen
PATCH: Für abwärtskompatible Fehlerbehebungen

Die MAJOR-Version ist die Version, die in der öffentlichen API verwendet wird. Diese Nummer wird in der Regel aktualisiert, wenn eine wichtige oder einschneidende Änderung an der API vorgenommen wird. Intern bedeutet eine solche Änderung, dass eine neue API-Instanz oder eine neue Ressource erstellt wurde.

Die MINOR- und PATCH-Versionen werden intern für Abwärtskompatibilitäts-Updates verwendet. Sie werden normalerweise aktualisiert, wenn neue Funktionen eingeführt werden oder wenn kleinere Änderungen an derselben API-Ressource vorgenommen werden. Die PATCH-Nummer wird speziell für Fehlerbehebungen oder Aktualisierungen zur Problemlösung aktualisiert.

Vorteile:
- Der gleichzeitige Zugriff auf mehrere Versionen ist möglich.
- Die URL-Benennung folgt einer einfachen, standardisierten Konvention, sodass die API-Endpunkte leicht zugänglich sind.
Beschränkungen:
- Bei grundlegenden Änderungen führt dieser Ansatz dazu, dass eine völlig neue API-Ressource entwickelt werden muss. Das kann deine Codebasis erheblich belasten.

Abfrageparameter

Eine andere Möglichkeit, eine REST-API zu versionieren, besteht darin, die Versionsnummer in die Abfrageparameter der URL aufzunehmen. Auf diese Weise kann die Serverumgebung auf die erforderliche Versionsnummer wie auf jeden anderen Abfrageparameter zugreifen und sie zur Umleitung des Kontrollflusses in der Anwendung verwenden. Du brauchst keine neue API-Ressource zu erstellen, da deine bestehende API-Ressource die Versionsnummer lesen und nach Bedarf verarbeiten kann.

So würde die URL aus dem vorherigen Beispiel aussehen, wenn sie mit Abfrageparametern versioniert würde:

http://example.com/api/resourcename?version=1

Vorteile:
- Sehr einfach im Code zu implementieren.
- Du kannst schnell auf die neueste Version umstellen.
Beschränkungen:
- Die Verwendung von Parametern zur Weiterleitung von Anfragen an die richtige Version kann schwieriger sein als die URI-Pfadversionierung.

Benutzerdefinierte Header

Du kannst REST-APIs auch versionieren, indem du benutzerdefinierte Header mit der Versionsnummer als Attribut angibst. Der wichtigste Unterschied zwischen dieser Methode und den beiden zuvor genannten ist, dass bei dieser Methode die Endpunkt-URL nicht mit Versionsinformationen überfrachtet wird.

So würde das Beispiel von vorhin aussehen, wenn es mit diesem Ansatz versioniert würde:

curl -H "Accepts-version: 2.0"

http://example.com/api/resourcename

Vorteile:
- Die URL wird nicht mit Versionsinformationen überfrachtet.
- Kunden können API-Endpunkt-URLs fest codieren und über Header zwischen den Versionen wählen, während sie die Anfrage schnell senden.
Beschränkungen:
- Du musst bei jeder Anfrage manuell benutzerdefinierte Header setzen.

Inhaltsaushandlung (Content Negotiation)

Die Inhaltsverhandlung ermöglicht es API-Entwicklern, eine einzelne Darstellung der Ressource statt der gesamten API zu versionieren. Dadurch erhalten sie eine genauere Kontrolle über die Versionierung. Genau wie bei der vorherigen Methode werden auch bei dieser Methode die API-URLs entrümpelt.

So würde unser Beispiel aussehen, wenn es über Content Negotiation versioniert würde:

curl -H "Accept: application/vnd.kb.api+json; version=2"

http://example.com/api/resourcename

Allerdings sind Endpunkte, die mit diesem Ansatz versioniert wurden, schwieriger zu erreichen als solche, die mit dem URI-Ansatz erstellt wurden. Außerdem macht es die Verwendung von HTTP-Headern mit Medientypen schwierig, die API in einem Browser zu testen. Und wenn der Content-Header optional ist, kann es zu Verwirrung darüber führen, welche Version die Clients standardmäßig erhalten.

Angenommen, du hast eine Version v2 für deine API veröffentlicht und die ältere Version v1 veraltet. Wenn ein Kunde die Version in seiner Anfrage nicht angibt, erhält er die v2-Ressource, was die Funktionalität aufgrund von nicht berücksichtigten Kompatibilitätsproblemen beeinträchtigen könnte. Aus diesem Grund wird Content Negotiation in der Regel nicht als Mittel zur API-Versionierung empfohlen

Vorteile:
- Du kannst bei Bedarf eine einzelne Ressource versionieren.
- Es schafft einen kleineren Code-Fußabdruck.
- Du musst keine Routingregeln (URLs) ändern.
Beschränkungen:
- HTTP-Header mit Medientypen machen es schwierig, die Endpunkte in einem Browser zu testen und zu untersuchen.
- Bedenke auch, dass das Fehlen von Content-Headern die Client-Funktionalität beeinträchtigen kann.

Beispiel für einen API-Endpunkt

Um APIs und Endpunkte besser zu verstehen, werden wir ein Beispiel anhand der Twitter-API erläutern. Diese API stellt Daten über Tweets, Direktnachrichten, Nutzer und mehr von der Social Media Plattform zur Verfügung. Sie bietet verschiedene Endpunkte, um verschiedene Operationen mit ihren Daten durchzuführen.

Du kannst zum Beispiel den Tweet-Lookup-Endpunkt (https://api.twitter.com/2/tweets/{id}) verwenden, um den Inhalt eines bestimmten Tweets mit Hilfe seiner eindeutigen Kennung abzurufen. Du kannst die Twitter API auch nutzen, um öffentliche Tweets in Echtzeit in deine Webanwendung zu streamen, um deine Nutzer über ein bestimmtes Thema zu informieren.

Die Twitter API bietet zu diesem Zweck einen gefilterten Stream-Endpunkt(https://api.twitter.com/2/tweets/search/stream). Sie hat auch einen erweiterten Index mit anderen Endpunkten erstellt, die du verwenden kannst.

Wie werden API-Endpunkte abgesichert?

Nachdem du nun weißt, wie ein API-Endpunkt aussieht und funktioniert, ist es wichtig zu wissen, wie er gesichert werden kann. Ohne angemessene Sicherheitsmaßnahmen kann ein API-Endpunkt eine große Schwachstelle in deiner App sein, die zu Daten- und Ressourcenverletzungen führen kann.

Hier sind einige grundlegende Vorschläge, um den Zugang zu deinen API-Endpunkten zu sichern.

One-Way Password Hashing

Bei der Erstellung von Webressourcen stößt du oft auf Passwörter, um Entitäten zu authentifizieren. Während Passwörter helfen, die Anwendungsdaten deiner Nutzer/innen zu schützen, musst du auch die Speicherung der Passwörter sichern, damit sie ein wirklich effektives Authentifizierungsmittel sind.

Generell solltest du Passwörter nie im Klartext speichern. Im Falle eines Sicherheitsverstoßes werden alle Benutzerkonten kompromittiert, wenn ein böswilliger Akteur die Tabelle mit den Paaren aus Benutzernamen und Passwort in die Hände bekommt.

Eine Möglichkeit, dies zu verhindern, ist, die Passwörter zu verschlüsseln, bevor sie gespeichert werden. Es gibt zwei Methoden der Verschlüsselung – symmetrisch und asymmetrisch.

Bei der symmetrischen Verschlüsselung kannst du zum Sperren und Entsperren des Inhalts denselben Schlüssel verwenden. Für Passwörter ist dies jedoch nicht empfehlenswert, da hartnäckige und raffinierte Hacker diese leicht knacken können.

Die empfohlene Art, Passwörter zu speichern, ist die einseitige oder „asymmetrische“ Verschlüsselung. Anstelle eines einzigen Schlüssels wird eine mathematische Funktion verwendet, um die Daten zu verschlüsseln.

Die verschlüsselte Version wird in der Datenbank gespeichert, sodass niemand, auch nicht die Serveradministratoren, die Passwörter entschlüsseln und einsehen kann. Zur Authentifizierung der Nutzer/innen wird das eingegebene Passwort durch dieselbe mathematische Funktion laufen gelassen und die Ergebnisse werden verglichen, um zu prüfen, ob das eingegebene Passwort korrekt war.

HTTPS

Angenommen, deine API-Endpunkte sind so konzipiert, dass Verbraucher mit deinen Diensten kommunizieren können. In diesem Fall setzt du sie einem erheblichen Risiko aus, wenn du kein HTTPS (oder ein ähnliches Sicherheitsprotokoll) implementierst.

Über API-Verbindungen werden normalerweise sensible Daten wie Passwörter, geheime Schlüssel und Zahlungsinformationen ausgetauscht. Solche Daten können leicht durch einen Machine-in-the-Middle-Angriff oder durch Packet-Sniffing-Methoden gestohlen werden.

Deshalb solltest du dich immer für HTTPS entscheiden, wenn es möglich ist. Wenn deine Anwendungen derzeit das HTTP-Protokoll verwenden, solltest du unbedingt auf HTTPS umsteigen. Es spielt keine Rolle, wie unbedeutend die Verbindung ist; sie kann immer zu einem Leck führen.

Du solltest auch ein TLS- oder SSL-Zertifikat in Erwägung ziehen, um die Sicherheit deiner API weiter zu erhöhen.

Ratenbegrenzung

In den meisten Fällen ist es eine gute Idee, die Anzahl der Zugriffe auf deine API in einer Minute zu begrenzen. So kannst du die missbräuchliche Nutzung von Ressourcen kontrollieren und ein Preismodell einführen, das auf dem Kundenverkehr basiert.

Ein wichtiger Grund für die Einführung einer Ratenbegrenzung ist jedoch die Vermeidung einer automatisierten Überbeanspruchung der Ressourcen, die in der Regel auf Bots zurückzuführen ist, die jede Sekunde Hunderte oder Tausende von gleichzeitigen Anfragen senden können. Die Ratenbegrenzung kann dir auch helfen, DDoS-Angriffe dieser Bots abzuwehren.

Die meisten Webentwicklungs-Frameworks bieten sofort einsatzbereite Middlewares zur Ratenbegrenzung, die sich leicht einrichten lassen. Selbst wenn dein Framework nicht über eine Middleware verfügt, kannst du sie über eine Bibliothek eines Drittanbieters beziehen und sie relativ schnell einrichten.

Abgesehen davon, dass du nach Bots Ausschau hältst, ist es auch eine gute Praxis, die Anzahl der zulässigen Anfragen oder Datenabrufe auf eine vernünftige Zahl zu begrenzen. So verhinderst du eine ungewollte Überbeanspruchung von Ressourcen, die durch manuelle Fehler wie Endlosschleifen ausgelöst werden kann. Es hilft auch, deinen Nutzern eine einheitliche Verfügbarkeit zu bieten – eine Nutzungsspitze bei einem Nutzer beeinträchtigt nicht die Erfahrung anderer Nutzer.

Maßnahmen zur API-Authentifizierung

Wenn du eine öffentlich zugängliche API aufbaust, musst du Authentifizierungsmaßnahmen einführen, um den Missbrauch deiner Dienste zu verhindern. Eine gute Möglichkeit ist das OAuth2-System.

Das OAuth2-System unterteilt dein Konto in Ressourcen und ermöglicht es dir, Inhabern von Authentifizierungstoken kontrollierten Zugang zu gewähren. Du kannst diese Token so einstellen, dass sie nach einer bestimmten Zeitspanne – z. B. 24 Stunden – ablaufen und danach erneuert werden. So wird sichergestellt, dass selbst wenn dein Token durchsickert, das begrenzte Nutzungsfenster die Auswirkungen des Lecks verringert.

Ein wesentlicher Bestandteil der API-Sicherheit ist die Verwendung von API-Schlüsseln zur Authentifizierung von Anfragen. Du kannst API-Schlüssel festlegen, um die Anzahl der Aufrufe an deine API zu begrenzen und die Wahrscheinlichkeit von DoS-Angriffen zu verringern. Wenn du einen kostenpflichtigen API-Dienst anbietest, kannst du API-Schlüssel verwenden, um den Zugang auf der Grundlage der von den Nutzern erworbenen Pläne zu ermöglichen.

Du solltest auch in Betracht ziehen, die Endpunkte deiner internen Mitarbeiter mit einer Multi-Faktor-Authentifizierung, Antivirensoftware und automatischen App-Updates auszustatten. Mit diesen einfachen Maßnahmen kannst du sicherstellen, dass die Qualität der von dir angebotenen Dienste nicht beeinträchtigt wird.

Eingabevalidierung

Auch wenn dies bei der Entwicklung einer Softwareanwendung selbstverständlich ist, wird es in überraschend vielen APIs nicht richtig umgesetzt. Bei der Eingabevalidierung geht es nicht nur darum, zu prüfen, ob die eingehenden Daten im richtigen Format vorliegen, sondern auch darum, nach Überraschungen Ausschau zu halten.

Eines der einfachsten, aber häufigsten Beispiele ist die SQL-Injection. Wenn du dich nicht darum kümmerst, kann deine gesamte Datenbank zerstört werden, wenn die falsche Abfrage ausgeführt wird. Achte darauf, dass die Eingabedaten das richtige Format haben und entferne die Zeichen, die auf eine böswillige Absicht hinweisen könnten.

Ein weiterer Punkt, auf den du achten solltest, ist die Größe der Anfrage. Bei POST-Anfragen führt der Versuch, eine extrem große Eingabe zu akzeptieren und zu analysieren, nur dazu, dass deine API überlastet wird. Du solltest dich immer darauf konzentrieren, die Größe einer POST-Anfrage zuerst zu überprüfen und dem Kunden gegebenenfalls einen angemessenen Fehlercode und eine entsprechende Meldung zu übermitteln.

IP-Adressen-Filterung

Wenn du B2B-Dienstleistungen anbietest und deine Kunden deine API von verschiedenen Standorten aus nutzen, solltest du eine zusätzliche Sicherheitsebene für deine Systeme einrichten, indem du die IP-Adressen, die auf deine API zugreifen, auf der Grundlage ihrer Standorte einschränkst.

Für neue Standorte und Kunden musst du deren Daten zu deiner Liste der „erlaubten Standorte“ hinzufügen. Das kann zwar den Einführungsprozess deiner Kunden erschweren, trägt aber wesentlich zur Verbesserung der Sicherheit und damit der Qualität des Kundenerlebnisses bei.

Um die Sicherheitsrisiken weiter zu minimieren, solltest du außerdem in Erwägung ziehen, die Berechtigungen und den Zugang deiner Kunden auf das für den Standardbetrieb erforderliche Minimum zu beschränken. Ebenso solltest du den HTTP-Zugang beschränken, um sicherzustellen, dass falsch konfigurierte Clients nur die API-Spezifikationen und den Zugangscode erhalten. Stelle sicher, dass deine API diese Anfragen mit einem 405-Antwortcode zurückweist.

Es ist erwähnenswert, dass ein großer Teil der weltweiten Cyberangriffe aus einer begrenzten Anzahl von Ländern kommt. Eine weitere gute Praxis ist es, den Zugriff auf deine Ressourcen von diesen Ländern aus komplett zu blockieren, wenn du dort keine Kunden hast.

Wenn du einen Angriff entdeckst, solltest du außerdem zunächst GET/POST-Anfragen aus der Region des Angreifers blockieren. Die Möglichkeit, HTTP-Anfragen auf der Basis von Kundenstandorten einzuschränken, ist eine der schnellsten Methoden, um einen laufenden Cyberangriff abzuwehren.

XDR (Extended Detection and Response)

Die meisten Unternehmen setzen traditionelle Sicherheitstools wie Firewalls und Techniken zum Schutz vor und zur Erkennung von Eindringlingen ein. Diese sind zwar rudimentär für jedes Sicherheitssystem, aber sie sind nicht speziell für APIs konzipiert.

Eine neue Technologie namens XDR bietet einen besseren und ganzheitlicheren Ansatz für den Schutz deiner gesamten IT-Umgebung, einschließlich deiner API-Endpunkte. XDR versorgt Sicherheitsteams mit Echtzeitwarnungen über bösartiges Verhalten, sodass sie Angriffe schnell untersuchen können.

Hier sind einige Möglichkeiten, wie XDT die API-Endpunkte schützt:

HTTPS-Überwachung: XDR kann die Sicherheitszertifikate deiner Endpunkte verwalten und auch die HTTP-Kommunikation überprüfen. Wenn es eine Anomalie feststellt, kann es die Verbindung schnell beenden oder andere automatische Maßnahmen ergreifen.
Überwachung von API-Aufrufen: XDR kann die Anzahl der von deinen Kunden getätigten API-Aufrufe verfolgen und deine Sicherheitsteams benachrichtigen, wenn es verdächtige Trends feststellt, selbst wenn sie innerhalb der festgelegten Ratengrenzen liegen.
JSON-Web-Token (JWT): JWT ist eine Standardmethode, um die Identität eines Nutzers bei der Kommunikation über ein Netzwerk sicher darzustellen. XDR kann dir dabei helfen, Nutzer über JWT in deinen Netzwerken zu identifizieren, ohne dass du Anmeldedaten übermitteln musst. So kannst du Benutzerkonten in deinem API-Datenverkehr identifizieren und ihr Verhalten auf Anomalien analysieren.
IP-Adressfilterung: XDR lässt sich gut in Threat Intelligence-Datenbanken integrieren und prüft eingehende Anfragen auf legitime IP-Adressen oder deren Herkunft.
Eingabevalidierung: Selbst wenn du in deinem Dienst keine geeigneten Maßnahmen zur Bereinigung von Eingaben implementiert hast, können XDR-Lösungen automatisch SQL- oder andere datenbanksensible Abfragen analysieren, um Injektionsangriffe zu erkennen, sie auf der Stelle zu stoppen und die Sicherheitsteams darüber zu informieren.

Wartungsroutinen

Es gibt ein paar allgemeine Wartungsroutinen, die du einrichten kannst, um die Qualität der Sicherheit deiner APIs zu verbessern. Hier sind einige von ihnen:

Daten bereinigen: Lösche überflüssige Benutzer- und Mitarbeiterdaten aus deinen Diensten. Eine routinemäßige Datenbereinigung ist nicht nur eine gute Praxis, sondern hilft auch, das Risiko eines versehentlichen Datenverlusts oder einer Datenbeschädigung zu verringern.
Führe regelmäßige Updates durch: Denke daran, deinen Tech-Stack und deine Service-Zertifizierungen regelmäßig zu aktualisieren. Du solltest routinemäßig Patches für deine Endpunktdienste einspielen, und alle deine Lizenzen sollten den neuesten Vorschriften und Compliance-Standards entsprechen.
Überprüfe die Sicherheitsmaßnahmen: Halte deine Sicherheits- und Wiederherstellungspläne auf dem neuesten Stand. Sie sollten so oft wie möglich die neuesten Änderungen oder Ergänzungen an deiner Netzwerkinfrastruktur berücksichtigen. Wenn du regelmäßig neue mobile, IoT- oder andere On-Premise-Ressourcen hinzufügst, ist diese Vorgehensweise sogar noch wichtiger.

Überwachung von API-Endpunkten

Nachdem du nun weißt, wie du API-Endpunkte erstellst, nutzt und sicher machst, musst du sie auch überwachen. Monitoring ist ein wichtiges Konzept, das in der Softwareentwicklung eingesetzt wird, um das Wachstum technischer Produkte zu analysieren und zu verstärken.

Tipps, Tricks und Best Practices

Im Fall von API-Endpunkten kann dir die Überwachung dabei helfen, deine Endpunkte zu sichern und zu optimieren, um ihre Leistung und Zuverlässigkeit zu verbessern. Im nächsten Abschnitt erfährst du, welche Best Practices du bei der Instrumentierung und Überwachung von API-Endpunkten beachten solltest.

1. Überprüfe die funktionale Betriebszeit

Im Allgemeinen neigen Teams dazu, die API-Verfügbarkeit oder Betriebszeit zu überwachen und sie als Standard für die Messung der Qualität von API-Diensten zu betrachten. Die Messung der allgemeinen API-Verfügbarkeit reicht jedoch für die verschiedenen Arten von Datenaustauschtransaktionen, die über die API stattfinden, nicht aus. Du musst die Verfügbarkeit und Leistung aller Verben (Erstellen, Lesen, Aktualisieren, Löschen usw.) einzeln überwachen, um sicherzustellen, dass sie alle funktionsfähig sind.

Dazu kannst du synthetische Überwachungstools mit mehrstufigen API-Monitoren einsetzen. So kannst du die Verfügbarkeit von API und Daten gleichzeitig verbessern. Gleichzeitig solltest du bedenken, dass die synthetische Überwachung eine begrenzte, vordefinierte Anzahl von API-Aufrufen zum Testen verwendet. Der tatsächliche Datenverkehr kann also von den Eingaben bei der synthetischen Überwachung abweichen.

2. Denke daran, API-Abhängigkeiten zu überwachen

Nicht jede API wird unabhängig entwickelt. Meistens musst du APIs von Drittanbietern nutzen, während du deine eigene erstellst. Und während du deinen Code bis in die tiefsten Ebenen instrumentieren kannst, vergisst du leicht, das Verhalten dieser Drittanbieter-APIs zu überwachen.

Deshalb musst du auch die Antworten der Drittanbieter-APIs verfolgen. Unserer Erfahrung nach haben fehlerhafte Abhängigkeiten immer dann für viel Aufregung gesorgt, wenn wir es versäumt haben, sie unabhängig zu analysieren.

3. Implementiere automatisierte Tests in der API-Überwachung

Wenn du eine gut definierte CI/CD-Pipeline eingerichtet hast, weißt du wahrscheinlich schon, wie wichtig die Automatisierung ist. Deshalb ist es am besten, wenn du neben der Überwachung auch automatisierte Tests für deine API-Endpunkte einrichten kannst. Du solltest in Erwägung ziehen, einen zusätzlichen Schritt in deine CI/CD-Pipelines aufzunehmen, um deine Endpunkte vor einer Veröffentlichung automatisch zu testen. Auch wenn dies heute zur Norm geworden ist, solltest du überprüfen, ob du es bereits implementiert hast oder nicht.

4. Wähle ein Tool mit einer starken Alerting-Funktionalität

Bei der Vielzahl an Tools, die derzeit auf dem Markt erhältlich sind, kann es schwierig sein, das richtige für deinen Anwendungsfall zu finden. Um dir die Suche zu erleichtern, gibt es eine kurze Regel, die du dir merken solltest: Achte immer auf eine starke Warnfunktion. Wenn dein ausgewähltes Tool dich nicht richtig über eingehende Probleme benachrichtigt, musst du immer wieder eingreifen, um zu prüfen, ob irgendwelche Ereignisse eingetreten sind. Die Automatisierung in diesem Bereich trägt wesentlich dazu bei, die Produktivität deines Teams zu steigern.

5. Priorisiere Tools, die direkt in deine CI/CD-Pipeline integriert werden können

Um die Effizienz deiner DevOps-Prozesse zu analysieren, solltest du in jeder Phase deiner CI/CD-Pipelines ein Monitoring integrieren. Dafür musst du sorgfältig Tools auswählen, die solche Funktionen bieten.

Um zu überprüfen, ob dein gewähltes Tool diese Funktion hat, schaue auf die Liste der angebotenen Drittanbieter-Integrationen. Wenn dein CI-Server, wie z. B. Jenkins oder GitHub, von dem Tool unterstützt wird, bist du startklar!

6. Keine Kompromisse beim API-Datenschutz eingehen

Einige API-Überwachungstools nutzen SaaS-Plattformen von Drittanbietern, die von ihren Kunden verlangen, dass sie bestimmte Ports auf ihren Firewalls öffnen, um ansonsten unerreichbare interne APIs zu überwachen. Diese stellen jedoch ein großes Sicherheitsrisiko dar. Jeder, der diese Ports kennt, kann sie nutzen, um sich unbefugt Zugang zu deinen Systemen zu verschaffen.

Deshalb ist es unerlässlich, eine gute API-Überwachungslösung zu wählen, die das Design deiner APIs berücksichtigt und es dir ermöglicht, jeden Endpunkt, ob intern oder extern, sicher zu überwachen. Die besten Tools für diesen Zweck sind diejenigen, die einen privaten Zugang zu deinen internen APIs ermöglichen, ohne Eindringlingen Raum zu geben.

7. 24/7 überwachen

Wenn du deine APIs nicht buchstäblich rund um die Uhr überwachst, kann dich das ein Vermögen kosten. Jeder Dienst kann zu jedem beliebigen Zeitpunkt ausfallen. Und wenn dein Überwachungsdienst zu diesem Zeitpunkt nicht erreichbar ist, musst du warten, bis der Dienst wieder funktioniert, um zu wissen, dass der Ausfall stattgefunden hat. In diesem Zeitfenster kannst du wertvolle Aufträge verlieren.

Deshalb empfehlen wir dir, hochfrequente Überwachungen einzurichten, die mindestens fünfmal pro Stunde für Funktionstests und einmal pro Stunde für die Sicherheits- und OAuth-Überwachung laufen.

8. Externe Überwachung vor interner Überwachung bevorzugen

Oftmals treten Probleme intern und extern nicht gleichmäßig auf. Deine Nutzer/innen könnten mit einem Problem konfrontiert werden, das du innerhalb der Firewalls deines Systems nicht reproduzieren kannst. In diesem Fall ist es egal, ob deine internen Metriken korrekt funktionieren; der Nutzer kann nicht auf dein Produkt zugreifen, also nützt dir jede Betriebsmetrik nichts.

Um solche Szenarien zu vermeiden, solltest du immer ein externes Überwachungssystem einem internen vorziehen. Um Probleme zu beheben, mit denen deine Nutzer/innen konfrontiert sind, musst du deine APIs aus der Sicht der Nutzer/innen betrachten.

9. Alle Ressourcen überwachen

Bei der Entwicklung des Dienstes oder der Anwendung, die hinter deiner API steht, entwickelst du vielleicht einige grundlegende oder komplexe Komponenten. Es kann zwar verlockend sein, die Überwachung der wesentlichen Komponenten zu überspringen, aber das ist nicht in allen Fällen eine gute Praxis. Oftmals kann ein scheinbar trivialer Fehler in einer unwichtigen, einfachen Komponente eine umfangreiche Anwendung zum Erliegen bringen.

Wenn du nicht überall deine Augen hast, musst du stundenlang nach der Komponente suchen, die das Problem verursacht hat, nur um dann festzustellen, dass das kleine Teil, das du für zu harmlos gehalten hast, tatsächlich der Übeltäter ist.

10. Analysiere alle Antwortparameter

Es reicht nicht aus, nur zu prüfen, ob der Statuscode 200 zurückgegeben wurde. Die meisten Entwickler verwenden grundlegende HTTP-Statuscodes wie 200 für Erfolg und 500 für einen Serverfehler, um allgemeine Antworten zu kennzeichnen. Erfolg oder Fehler können jedoch verschiedene Formen annehmen, und es ist wichtig, jede einzelne davon zu verfolgen, um festzustellen, wie deine APIs funktionieren.

Du solltest auch auf Veränderungen in der Größe der von den APIs zurückgegebenen Inhalte achten. Wenn die übliche Antwort 500 kb groß ist, du aber nur 100 kb oder weniger erhalten hast, ist wahrscheinlich ein Fehler aufgetreten.

API-Überwachungstools

Um die oben genannten Best Practices umzusetzen, musst du mit einer API-Überwachungslösung beginnen. Während es in Frameworks wie WordPress gebrauchsfertige Plugins für die API-Überwachung gibt, musst du dich bei rein programmierten Anwendungen nach einer umfassenderen Lösung umsehen.

Im nächsten Abschnitt stellen wir dir eine kleine Auswahl an trendigen API-Überwachungstools vor, die dir den Einstieg mit minimalem Aufwand und Kosten erleichtern.

Uptrends

Uptrends bietet Monitoring für Webanwendungen, APIs, Server und vieles mehr. Uptrends hat einen riesigen Kundenstamm von über 25.000 kleinen und großen Unternehmen, darunter so bekannte Namen wie Microsoft, Vimeo und Volkswagen.

Ein besonderes Merkmal dieses Anbieters ist das browserbasierte Testen. Er nutzt echte, einzigartige Browser, um deine Apps und Websites auszuführen und detaillierte Leistungsdaten zu erfassen.

Antwortzeiten und Kennzahlen sind jedoch nicht die einzigen Funktionen des Dienstes. Mit Uptrends erhältst du auch einen detaillierten Leistungsbericht zu jeder deiner Ressourcen, damit du alle möglichen Arten von Engpässen in deinem System verstehen kannst. Für jeden Fehler macht Uptrends einen Screenshot und schickt ihn an dich, damit du den Fehler so erleben kannst, wie er aufgetreten ist.

Dotcom-Monitor

Dotcom-Monitor ist stolz darauf, dass es Benutzern ermöglicht, ein Multitasking-Überwachungsgerät mit einem HTTP- oder HTTPS-Job zu konfigurieren. Damit kannst du Web-APIs auf Verfügbarkeit, korrekte Antworten und Leistung überwachen.

Die Agenten von Dotcom-Monitor replizieren eine oder mehrere Client-Anfragen, um zu überprüfen, ob die Daten zwischen der API und den Clients ordnungsgemäß ausgetauscht werden können. Wenn einer der Agenten einen Fehler feststellt, vergleicht er ihn mit einer Liste von voreingestellten Filtern. Wenn der Fehler nicht herausgefiltert werden soll, löst der Agent eine Warnung aus.

Mit dem Tool kannst du individuelle Alarmzeitpläne und Eskalationsalternativen einrichten. Du kannst Fehlerberichte in verschiedenen Formaten exportieren, darunter CSV, PDF, TXT und mehr. Die Fehlerberichte von Dotcom-Monitor zeigen verschiedene wertvolle Metriken wie Ausfallzeiten, Antwortzeiten und die durchschnittliche Leistung nach Standort.

Dotcom-Monitor gehört zu den erschwinglichsten API-Überwachungslösungen und ist bereits ab 1,99 US-Dollar pro Monat erhältlich. Wenn du ein wachsendes Unternehmen mit einem begrenzten Budget bist, könnte Dotcom-Monitor genau die richtige API-Überwachungslösung für dich sein.

Graphite

Graphite ist ein Open-Source-API-Überwachungssystem, mit dem du Metriken von APIs erfassen kannst, indem du den Dienst die Daten in Graphites Carbon-Komponente pushen lässt. Graphite speichert diese Daten dann in einer Datenbank, um daraus Erkenntnisse zu gewinnen.

Graphite ist bei seinen Nutzern beliebt, weil der Installationsprozess so einfach ist. Dazu gehört ein automatisches Installations- und Konfigurationsskript für den Stack, bekannt als Synthesize.

Ein weiteres herausragendes Merkmal von Graphite ist die Möglichkeit, beliebige Ereignisse zu speichern. Diese Ereignisse beziehen sich in der Regel auf Zeitserienmetriken. So kann dein Entwicklungsteam die Ursache von Problemen und Engpässen schneller finden und mehr Informationen über die Ereignisse und Anomalien erhalten, die zu unerwartetem Verhalten führen.

Sematext

Sematext ist eine beliebte Lösung für DevOps-Teams, weil es eine Reihe von Monitoring-Tools bietet. Die API-Überwachung ist Teil des synthetischen Überwachungsdienstes, der als Sematext Synthetics bekannt ist.

Sematext bietet ein komplexes API-Überwachungs- und Warnsystem, das du auf der Grundlage verschiedener Fehler und Metriken anpassen kannst. Du kannst dieses Tool so einrichten, dass es eine doppelte oder dreifache Prüfung durchführt, bevor es einen Alarm sendet. Es kann dir dabei helfen, falsch-positive Meldungen zu eliminieren und genauere und relevantere Informationen zu liefern.

Neben dem leistungsstarken HTTP-Monitor, den Sematext anbietet, erhältst du auch eine umfassende Browser-Überwachungsfunktion. Sie ermöglicht es dir, Web-Performance-Metriken auf der Grundlage von vordefinierten Benutzerinteraktionen mit deinen Webanwendungen zu sammeln. Das bedeutet, dass du über die üblichen Teststandards hinausgehen kannst, indem du die Ladezeiten von Seiten, die Ladezeiten von Inhalten usw. verfolgst und einen detaillierten Blick auf emulierte Benutzerinteraktionen wie den In-App-Authentifizierungsfluss, die Ausführung von Suchanfragen oder das Hinzufügen oder Entfernen von Artikeln aus einem Warenkorb wirfst. Sematext bietet verschiedene solcher Benutzerinteraktionen von Haus aus.

BlazeMeter

Blazemeter ist eine erstklassige End-to-End-Test- und Überwachungslösung für moderne Anwendungen. Das Tool gibt dir völlige Freiheit bei der Auswahl von Open-Source-Testframeworks und deren Analyse mithilfe einfacher Dashboards. Außerdem lässt es sich nahtlos in Apache JMeter integrieren, das zu den besten Tools für die Leistungsmessung komplexer Webanwendungen gehört.

Wie die meisten API-Überwachungslösungen bietet auch BlazeMeter grundlegende Funktionen wie funktionale Tests (sogenannte „Szenarien“), die du über eine interaktive grafische Benutzeroberfläche einrichten kannst. BlazeMeter stellt über sein spezielles Testwerkzeug Taurus eine DSL (Domain Specific Language) zur Verfügung, die es Entwicklern ermöglicht, generische Tests zu schreiben. Diese Tests können dann mit JMeter und anderen gängigen Open-Source-Tools ausgeführt werden.

Aufgrund seines schwergewichtigen Designs liegt der Preis von BlazeMeter auf der höheren Seite. Wenn deine App mehr als 5.000 gleichzeitige Nutzer hat, solltest du bereit sein, mehr als 600 US-Dollar pro Monat auszugeben. Du kannst dich aber auch für Tarife mit festen Kosten entscheiden, die sich nach deiner Nutzung richten.

Wenn dein Produkt in der Reihe von Pfizer, Adobe, NFL, Atlassian usw. steht, ist BlazeMeter die perfekte API-Überwachungslösung für dich.

Auch wenn dies eine recht übersichtliche Sammlung von API-Überwachungstools ist, gibt es noch viele weitere großartige Optionen. Sieh dir unbedingt die ausführliche Sammlung von API-Überwachungstools von Geekflare und den umfassenden Kaufratgeber für API-Überwachungstools von Sematext an, bevor du eine Entscheidung triffst!

Zusammenfassung

APIs sind das Rückgrat der modernen Computermaschinerie. Die meisten Produkte auf dem Softwaremarkt werden mit einer API geliefert, um eine nahtlose Integration mit Drittanbietern zu ermöglichen. Um ein reibungsloses Nutzererlebnis zu bieten und deine Kunden an dich zu binden, solltest du in Erwägung ziehen, mit deinem Softwareprodukt eine API zu erstellen und bereitzustellen… das heißt, du musst APIs in- und auswendig kennen.

Dieser Leitfaden soll dir den Einstieg in diesen Bereich erleichtern, indem er dich in die Grundlagen dieser Technologie einführt und dir grundlegende Konzepte, bewährte Verfahren und hilfreiche API-Überwachungswerkzeuge auf dem Markt vorstellt. Hoffentlich hast du jetzt ein besseres Verständnis dafür, wie Webressourcen miteinander kommunizieren.

Trotz allem, was wir besprochen haben, haben wir hier kaum an der Oberfläche gekratzt, was APIs und API-Endpunkte alles leisten können. Lies weiter, teste und wende dich an die Entwicklergemeinschaft, um dein Wissen und deine Fähigkeiten mit API-Endpunkten zu erweitern.