Wie erstellen Sie eine REST-API mit Flask auf Ubuntu?

Einführung

In diesem Leitfaden lernst du, wie du mit Flask, einem leichten Python-Web-Framework, eine einfache REST-API erstellen kannst. Wir werden die Grundlagen der Einrichtung einer Flask-Anwendung, die Definition von Routen, die Verarbeitung von Anfragen und die Rückgabe von JSON-Antworten behandeln. Am Ende dieses Leitfadens hast du eine funktionierende API, die du erweitern und mit anderen Anwendungen integrieren kannst.

Voraussetzungen

• Ein Server mit Ubuntu, ein Nicht-Root-Benutzer mit sudo-Berechtigungen und einer aktiven Firewall. Wenn du Hilfe benötigst, um dies zu einrichten, wähle deine Distribution von dieser Liste aus und folge unserem Leitfaden für die Einrichtung des initialen Servers. Stelle sicher, dass du mit einer unterstützten Version von Ubuntu arbeitest.

• Vertrautheit mit der Linux-Befehlszeile. Wenn Sie eine Einführung oder Auffrischung in die Befehlszeile benötigen, können Sie sich diese Anleitung zu einem Linux-Befehlszeilen-Einstieg ansehen

• Ein grundlegendes Verständnis der Python-Programmierung.

• Python 3.7 oder höher installiert auf Ihrem Ubuntu-System. Wie Sie ein Python-Skript unter Ubuntu ausführen können, erfahren Sie in unserem Tutorial zu Wie Sie ein Python-Skript unter Ubuntu ausführen.

Schritt 1 — Einrichten Ihrer Flask-Umgebung

Ubuntu 24.04 enthält Python 3 standardmäßig.Öffnen Sie die Konsole und führen Sie das folgende Kommando aus, um die Installation von Python 3 zu überprüfen:

root@ubuntu:~# python3 --version
Python 3.12.3

Wenn Python 3 bereits auf Ihrem Rechner installiert ist, liefert das oben genannte Kommando die aktuelle Version der Python 3-Installation zurück. Wenn es nicht installiert ist, können Sie das folgende Kommando ausführen, um Python 3 zu installieren:

root@ubuntu:~# sudo apt install python3

Nächstes, was Sie tun müssen, ist die Installation des pip-Paketinstallers auf Ihrem System:

root@ubuntu:~# sudo apt install python3-pip

Sobald pip installiert ist, installieren wir Flask.

Sie installieren Flask über pip. Es wird empfohlen, dies in einer virtuellen Umgebung zu tun, um Konflikte mit anderen Paketen auf Ihrem System zu vermeiden.

root@ubuntu:~# python3 -m venv meinprojektumgebung
root@ubuntu:~# source meinprojektumgebung/bin/activate

root@ubuntu:~# pip install Flask

Schritt 2 – Erstellen einer Flask-Anwendung

Der nächste Schritt besteht darin, den Python-Code für die Flask-Anwendung zu schreiben. Um ein neues Skript zu erstellen, navigieren Sie zu Ihrem ausgewählten Verzeichnis:

root@ubuntu:~# cd ~/pfad-zum-skriptverzeichnis

Wenn Sie sich im Verzeichnis befinden, erstellen Sie ein neues Python-Datei, app.py, und importieren Sie Flask. Schließen Sie dann eine Flask-Anwendung initial ein und erstellen Sie eine grundlegende Route.

root@ubuntu:~# nano app.py

Dadurch wird ein leeres Texteditore geöffnet. Schreiben Sie Ihre Logik hier oder kopieren Sie den folgenden Code:

from flask import Flask, jsonify, request

app = Flask(__name__)

@app.route('/')
def hello_world():
    return jsonify(message="Hello, World!")

# In-memory data store
items = [{"id": 1, "name": "This is item 1"}, {"id": 2, "name": "This is item 2"}]

Schritt 3 – Erstellen von RESTful Routen

In diesem Abschnitt definieren wir in unserer Flask-Anwendung Routen, die auf die verschiedenen Aktionen reagieren, die ein Benutzer auf der API durchführen kann. Jede Route wird eine bestimmte HTTP-Methode verarbeiten.

GET, POST, PUT, und DELETE. Diese Methoden entsprechen den vier grundlegenden Operationen des persistenten Speichernamens – oft als CRUD (Erstellen, Lesen, Aktualisieren, Löschen) bezeichnet.

Fügen Sie den folgenden Routen Ihrem Python-Skript app.py hinzu:

from flask import Flask, jsonify, request

app = Flask(__name__)

@app.route('/')
def hello_world():
    return jsonify(message="Hello, World!")

# In-memory data store
items = [{"id": 1, "name": "This is item 1"}, {"id": 2, "name": "This is item 2"}]

# GET Anfrage: Alle Elemente abrufen
@app.route('/api/items', methods=['GET'])
def get_items():
    return jsonify(items)

# GET Anfrage: Ein bestimmtes Element anhand der ID abrufen
@app.route('/api/items/<int:item_id>', methods=['GET'])
def get_item(item_id):
    item = next((item for item in items if item["id"] == item_id), None)
    if item is None:
        return jsonify({"error": "Item not found"}), 404
    return jsonify(item)

# POST Anfrage: Ein neues Element erzeugen
@app.route('/api/items', methods=['POST'])
def create_item():
    new_item = {"id": len(items) + 1, "name": request.json.get('name')}
    items.append(new_item)
    return jsonify(new_item), 201

# PUT Anfrage: Ein existierendes Element aktualisieren
@app.route('/api/items/<int:item_id>', methods=['PUT'])
def update_item(item_id):
    item = next((item for item in items if item["id"] == item_id), None)
    if item is None:
        return jsonify({"error": "Item not found"}), 404
    item['name'] = request.json.get('name', item['name'])
    return jsonify(item)

# DELETE Anfrage: Ein Element löschen
@app.route('/api/items/<int:item_id>', methods=['DELETE'])
def delete_item(item_id):
    global items
    items = [item for item in items if item["id"] != item_id]
    return '', 204

if __name__ == "__main__":
    app.run(debug=True)

Lassen Sie uns mehr über die Funktion jedes Elements erfahren:

• Flask-Imports: Der Code importiert notwendige Komponenten von Flask: Flask, jsonify und request.

• In-Memory Data Store: items ist eine einfache Liste von Dictionarys, die als temporärer Datenspeicher für die API fungiert. Jedes Element hat ein id und einen name.

• GET /api/items: Wenn eine GET-Anfrage an /api/items gestellt wird, liefert der Server eine Liste aller Elemente im Elementen Datenbank. Dies ist nützlich, um alle Ressourcen in einer Sammlung aufzurufen.

• POST /api/items: Ein POST-Anfrage an /api/items ermöglicht dem Client, ein neues Element zu erstellen. Der Server erwartet ein JSON-Objekt, das die Details des neuen Elements im Anfragestrom enthält. Nach der Erstellung des Elements reagiert der Server mit dem neu erstellten Element und einem 201 Created-Statuscode.

• PUT /api/items/<int:item_id>: Ein PUT-Anfrage an /api/items/<item_id> wird verwendet, um ein existierendes Element mit der angegebenen item_id zu aktualisieren. Der Client sendet die aktualisierten Daten im Anfragestrom und der Server ändert das existierende Element. Wenn das Element nicht gefunden wird, sendet der Server einen 404 Not Found-Fehler.

• DELETE /api/items/<int:item_id>: Ein DELETE-Anfrage an /api/items/<item_id> entfernt das Element mit der angegebenen item_id aus dem Datenpool. Wenn die Element entfernt wird, sendet der Server eine 204 No Content-Statuszeile zurück, was bedeutet, dass die Löschung erfolgreich war und es keinen weiteren Inhalt zu senden gibt.

• Anwendungsbetrieb: Der Block if __name__ == "__main__": stellt sicher, dass die Flask-Anwendung ausgeführt wird, wenn das Skript direkt ausgeführt wird.

Schritt 4 — API starten und testen

Starten Sie den Flask-Server mit dem folgenden Befehl:

root@ubuntu:~# python3 app.py

Sie sollten den Flask-Server mit der folgenden Ausgabe bemerken:

Output
* Serving Flask app 'app'
 * Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on http://127.0.0.1:5000
Press CTRL+C to quit
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 837-877-972

Aus der obenstehenden Ausgabe können Sie erkennen, dass der Server unter http://127.0.0.1 läuft und auf Port 5000 lauscht.

Nun können Sie die Endpunkte mit curl, Postman oder einem anderen HTTP-Client testen. In diesem Leitfaden verwenden Sie curl, um die Endpunkte zu testen und HTTP-Anfragen zu senden.

Öffnen Sie eine weitere Ubuntu-Konsole und führen Sie die untenstehenden curl-Befehle einzeln aus:

• GET: curl http://127.0.0.1:5000/api/items
• POST: curl -X POST -H "Content-Type: application/json" -d '{"name": "This is item 3"}' http://127.0.0.1:5000/api/items
• PUT: curl -X PUT -H "Content-Type: application/json" -d '{"name": "This is updated item 1"}' http://127.0.0.1:5000/api/items/1
• DELETE: curl -X DELETE http://127.0.0.1:5000/api/items/1

Lassen Sie uns die Wirkung jeder dieser Befehle anschauen:

root@ubuntu:~# curl http://127.0.0.1:5000/api/items

Output
[
  {
    "id": 1,
    "name": "This is item 1"
  },
  {
    "id": 2,
    "name": "This is item 2"
  }
]

Du wirst bemerken, dass der Server eine Liste aller Elemente im Artikel Datenbankobjekt zurückgibt.

Verwende den POST-Methode, lass uns einen neuen Artikel in der Datenbank hinzufügen.

root@ubuntu:~# curl -X POST -H "Content-Type: application/json" -d '{"name": "Dies ist Artikel 3"}' http://127.0.0.1:5000/api/items

Output
{
  "id": 3,
  "name": "This is item 3"
}

* Running on http://127.0.0.1:5000
Press CTRL+C to quit
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 837-877-972
127.0.0.1 - - [23/Aug/2024 06:57:27] "GET /api/items HTTP/1.1" 200 -
127.0.0.1 - - [23/Aug/2024 06:59:56] "POST /api/items HTTP/1.1" 201 -

Nächstes, lass uns eine PUT-Anfrage ausführen. Ein PUT-Anfrage an /api/items/<item_id> wird ein bestehendes Element mit der angegebenen item_id aktualisieren.

root@ubuntu:~# curl -X PUT -H "Content-Type: application/json" -d '{"name": "Dies ist aktualisierter Artikel 1"}' http://127.0.0.1:5000/api/items/1

Output
{
  "id": 1,
  "name": "This is updated item 1"
}

Nun lass uns eine GET-Anfrage ausführen, um den aktualisierten Artikel 1 zu sehen.

root@ubuntu:~# curl http://127.0.0.1:5000/api/items/1

Output
{
  "id": 1,
  "name": "This is updated item 1"
}

Schließlich lass uns eine DELETE-Anfrage ausführen, um ein Element aus der Datenbank zu löschen.

root@ubuntu:~# curl -X DELETE http://127.0.0.1:5000/api/items/1

Dadurch wird Artikel 1 aus der Datenbank gelöscht.

Um dies zu verifizieren, lass uns eine GET-Anfrage ausführen.

root@ubuntu:~# curl http://127.0.0.1:5000/api/items

Output
[
  {
    "id": 2,
    "name": "This is item 2"
  },
  {
    "id": 3,
    "name": "This is item 3"
  }
]

Sie werden erkennen, dass Artikel 1 nicht mehr vorhanden ist und dauerhaft gelöscht wurde.

Fazit

In diesem Lehrbuch haben Sie eine grundlegende REST-API-App mit Flask erstellt. Sie können diese API nun mit zusätzlichen Routen erweitern, mit einer Datenbank integrieren oder auf einer Cloud-Plattform wie DigitalOcean部署. Flask ist ein leistungsstarkes Werkzeug für die schnelle und effiziente Erstellung von APIs und mit diesen Grundlagen sind Sie bereit, komplexere Anwendungen zu entwickeln.