

Discover more from Tinz Twins Tech Blog
Im Internet ist eine große Menge an Daten verfügbar. Anwendungen von Drittanbietern können über ein Application Programming Interface (API) auf diese Daten zugreifen. Solche Dienste werden auch als Webdienste bezeichnet. Eine der beliebtesten Methoden zur Erstellung von APIs ist die REST-Architektur (Representational State Transfer). In diesem Artikel lernst du die Grundlagen von REST kennen und erfährst, wie du REST-APIs erstellen und verwenden kannst. Python bietet großartige Packages zum Abrufen von Daten über REST-APIs und zum Erstellen eigener REST-APIs.
Zunächst möchten wir dir einen Überblick über diesen Artikel geben. Wir behandeln folgende Themen:
REST Prinzipien
REST-API Grundlagen
Erstellen von REST-APIs mit Python
Verwenden von REST-APIs mit Python
REST Prinzipen
Die Grundlage von REST ist das Client-Server-Modell über ein Netzwerk. REST hat einige Einschränkungen für die Software-Architektur. Diese Einschränkungen dienen dazu, die Leistung, Skalierbarkeit, Einfachheit und Zuverlässigkeit des Systems zu fördern.
REST Einschränkungen
Zustandslos: Der Server speichert keinen Zustand zwischen den Anfragen des Clients.
Client-Server: Der Client und der Server sind voneinander entkoppelt und werden unabhängig voneinander entwickelt.
Caching: Zwischenspeicherung der vom Server abgerufenen Daten auf dem Client oder dem Server.
Einheitliche Schnittstelle: Der Server bietet eine einheitliche Schnittstelle für den Zugriff auf die Ressourcen.
Mehrschichtiges System: Der Client kann indirekt auf die Ressourcen des Servers zugreifen (z.B. Proxy oder Load Balancer).
Code auf Anfrage (optional): Der Server kann Code (z. B. JavaScript) an den Client liefern. Der Client kann diesen Code dann auf der Client-Seite ausführen.
REST-API Grundlagen
REST-APIs ermöglichen den Zugriff auf Webdienste über eine öffentliche Web-URL. Du greifst auf Daten über eine REST-API zu, indem du eine HTTP-Anfrage an eine URL sendest. Anschließend erhältst du eine Antwort vom Server.
HTTP Methoden
REST-APIs hören auf HTTP-Methoden wie GET, POST und DELETE. Eine Ressource ist die Gesamtheit der im Webdienst verfügbaren Daten. Die HTTP-Methode teilt der API mit, welche Aktion mit der Ressource durchgeführt werden soll.
Übersicht von HTTP Methoden:
GET: Abrufen von Daten aus einer vorhandenen Ressource.
POST: Erstellen einer neuen Ressource.
PUT: Aktualisieren einer bestehenden Ressource.
PATCH: Teilweise Aktualisierung einer bestehenden Ressource.
DELETE: Löschen einer bestehenden Ressource.
Status Codes
Auf eine HTTP-Anfrage erhältst du eine HTTP-Antwort mit einem Statuscode. Dieser Statuscode informiert den Client über die Ergebnisse der Anfrage. Eine Client-Anwendung kann den Statuscode prüfen und auf dieser Grundlage weitere Aktionen durchführen.
Wichtige Status Codes
200: OK
201: Created
202: Accepted
404: Not Found
422: Unprocessable Entity
500: Internal Server Error
Ausführlichere Informationen über Statuscodes findest du auf dieser Website.
API Endpoints
Die öffentlichen URLs, die von einer REST-API bereitgestellt werden, werden als Endpunkte bezeichnet. Hier sind ein paar Beispiele:
Jeder Endpunkt führt je nach HTTP-Methode eine andere Aktion aus. Um mit einem API-Endpunkt zu interagieren, benötigest du die Basis-URL des Webdienstes. In unserem Beispiel nehmen wir an, dass https://example.api.com/ die Basis-URL ist. Dann kannst du mit https://example.api.com/companies auf den ersten GET-Endpunkt in der Tabelle zugreifen. Produktionsfähige Anwendungen haben Hunderte von verschiedenen Endpunkten oder mehr, um Ressourcen zu verwalten.
Erstellen von REST-APIs in Python
Die Entwicklung einer REST-API ist eine große Herausforderung. Du solltest die Best Practices kennen, um wartbare APIs zu erstellen. Wir zeigen dir, welche Schritte du bei der Erstellung einer REST-API befolgen solltest.
Empfohlene Schritte
Identifikation der Ressourcen: Du musst die Ressourcen identifizieren, die von der REST-API verwaltet werden sollen. Es ist üblich, bei diesen Ressourcen im Plural zu sprechen, z. B. companies.
Definition der Endpunkte: Sobald du alle Ressourcen identifiziert hast, kannst du die einzelnen Endpunkte definieren. Ein Endpunkt enthält keine Verben. Du kannst auch eine verschachtelte Ressource verwenden (z. B. /companies/<company_id>/balance_sheets). Es ist auch sinnvoll, die API-Versionierung zu verwenden. Deine Ressourcen ändern sich mit der Zeit und damit auch deine REST-API. Die API-Versionierung ermöglicht die Abwärtskompatibilität. Die URI-Versionierung ist sehr beliebt.
Definition des Datenformats: Das Format JavaScript Object Notation (JSON) ist das beliebteste Format bei REST-APIs. JSON speichert Daten in Key-Value-Paaren, ähnlich wie ein Dictionary in Python. Unten siehst du ein Beispiel.
{
"isin": "US8522341036",
"name": "Block",
"symbol": "SQ"
}
Entwerfen von Success Responses and Error Responses:
Du solltest darauf achten, dass die Antworten ein einheitliches Format haben. Nehmen wir an, dass wir JSON als Austauschformat verwenden. Die Antwort enthält daher Daten im JSON-Format. Es ist wichtig, dass in der Antwort der content-type Header auf application/json gesetzt ist. Dieser Header teilt der Client-Anwendung mit, wie die Antwortdaten zu parsen sind.
Die Frameworks Flask, Django REST Framework und FastAPI sind unter Python-Entwicklern sehr beliebt.
Nutzung von APIs mit Python
Unserer Meinung nach ist das beste Werkzeug für die Interaktion mit REST-APIs in Python das Paket requests. Um requests zu verwenden, musst du das Paket mit pip installieren. Wir empfehlen, dass du zunächst eine virtuelle Umgebung (z. B. conda) erstellst. Anschließend kannst du das Paket in dieser virtuellen Umgebung installieren.
Installation von requests:
pip install requests
Wir zeigen dir, wie du requests verwenden kannst, um mit einer REST-API zu interagieren. Um das Paket zu demonstrieren, verwenden wir die kostenlose Fake-API JSONPlaceholder.
GET
import requests
url = 'https://jsonplaceholder.typicode.com/todos/1'
response = requests.get(url)
print(response.json())
print(response.status_code)
print(response.headers['Content-Type'])
# Output
# {'userId': 1, 'id': 1, 'title': 'delectus aut autem', 'completed': False}
# 200
# application/json; charset=utf-8
Dieser Python Code sendet eine GET-Anfrage an /todos/1
. Die Antwort ist das Todo-Element mit der id=1
. Mit .json()
auf dem Objekt response
kannst du die Daten von der API als JSON-String ausgeben. Darüber hinaus kannst du den Statuscode und den HTTP-Header ausgeben.
POST
import requests
url = 'https://jsonplaceholder.typicode.com/todos'
todo = {"userId": 1, "title": "Buy Tesla shares", "completed": False}
response = requests.post(url, json=todo)
print(response.json())
print(response.status_code)
# Output
# {'userId': 1, 'title': 'Buy Tesla shares', 'completed': False, 'id': 201}
# 201
Das todo
Dictionary enthält die Informationen für ein neues todo-Element. Dann übergibst du das Dictionary an das keyword argument json
. Anschließend setzt die Funktion requests.post()
den Content-Type Header automatisch auf application/json
. Die Antwort enthält einen JSON-String und den Statuscode 201
(Created).
PUT
import requests
url = 'https://jsonplaceholder.typicode.com/todos/10'
todo = {"userId": 1, "title": "Buy Apple shares", "completed": False}
response = requests.put(url, json=todo)
print(response.json())
print(response.status_code)
# Output
# {'userId': 1, 'title': 'Buy Apple shares', 'completed': False, 'id': 10}
# 200
Mit der Methode requests.put()
aktualisieren wir das Element mit id=10
. Die Antwort der REST-API enthält einen JSON-String mit id=10
. Außerdem erhalten wir den Statuscode 200
(OK) zurück. Die Ressource wurde also erfolgreich aktualisiert.
PATCH
import requests
url = 'https://jsonplaceholder.typicode.com/todos/7'
todo = {"title": "Buy Block shares"}
response = requests.patch(url, json=todo)
print(response.json())
print(response.status_code)
# Output
# {'userId': 1, 'id': 7, 'title': 'Buy Block shares', 'completed': False}
# 200
Nun verwenden wir requests.patch()
, um ein bestimmtes Feld eines bestehenden ToDo-Elements zu aktualisieren. Die Antwort ist das aktualisierte ToDo-Element und der Statuscode 200
(OK).
DELETE
import requests
url = 'https://jsonplaceholder.typicode.com/todos/10'
response = requests.delete(url, json=todo)
print(response.json())
print(response.status_code)
# Output
# {}
# 200
Du kannst eine Ressource auch mit requests.delete()
entfernen. Die Variable url
enthält die id=10
, die wir entfernen möchten. Die REST-API gibt einen leeren JSON-String und den Statuscode 200
(OK) zurück.
Das Package requests ist ein hervorragendes Werkzeug für die Interaktion mit REST-APIs in Python.
Fazit
In diesem Artikel haben wir dir die Grundlagen von REST-APIs vorgestellt. REST-APIs sind die Helden der modernen Webentwicklung.
Lessons learned:
Verständnis über den REST-Architekturstil
HTTP-Methoden und Statuscodes
Best Practices für die Definition von Endpunkten
Verwendung des requests Packages zur Interaktion mit REST-APIs
👉🏽 Du findest alle digitalen Produkte von uns in unserem Online Shop! Schaue gerne mal vorbei.
Dir gefällt unserer Content und wir konnten dir weiterhelfen? Dann unterstütze uns doch, indem du unsere Spendenoption auf Buy me a coffee nutzt oder unsere Artikel mit anderen teilst. Vergesse auch nicht, uns auf YouTube zu folgen. Vielen Dank für deine Unterstützung! 🙏🏽🙏🏽
Erfahre mehr über uns auf unserer About-Seite. Du kannst unseren Tech Blog auch gerne weiterempfehlen. Nutze hierfür einfach unser Empfehlungsprogramm und sichere dir Vorteile. Vielen Dank fürs Lesen.
Referenzen
* Affiliate-Link / Anzeige: Die Links sind Affiliate-Links, d.h. wir erhalten eine Provision, wenn du über diese Links einkaufst. Es entstehen keine zusätzlichen Kosten für dich.