Python: Erstellen einer REST-API

Wie man eine REST-API mit Flask erstellt

👋 Willkommen bei der Stackhero-Dokumentation!

Stackhero bietet eine einsatzbereite Python-Cloud-Lösung, die zahlreiche Vorteile bietet, darunter:

  • Deployen Sie Ihre Anwendung in Sekundenschnelle mit einem einfachen git push.
  • Verwenden Sie Ihren eigenen Domainnamen und profitieren Sie von der automatischen Konfiguration von HTTPS-Zertifikaten für erhöhte Sicherheit.
  • Genießen Sie beruhigende automatische Backups, Ein-Klick-Updates und eine einfache, transparente und vorhersehbare Preisgestaltung.
  • Erhalten Sie optimale Leistung und robuste Sicherheit dank einer privaten und dedizierten VM.

Sparen Sie Zeit und vereinfachen Sie Ihr Leben: Es dauert nur 5 Minuten, um die Python-Cloud-Hosting-Lösung von Stackhero auszuprobieren!

Diese Dokumentation ist ein anfängerfreundlicher Leitfaden zur Erstellung einer REST-API in Python.

In diesem Beispiel verwenden wir Flask, ein leichtgewichtiges und einfach zu bedienendes Mikro-Framework, das es Ihnen ermöglicht, schnell Webanwendungen zu erstellen.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Ihr Computer mit den folgenden Tools ausgestattet ist:

  1. Python
  2. pip
  3. git
  4. asdf

Wenn Ihre Entwicklungsumgebung noch nicht eingerichtet ist, lesen Sie den Development platform Leitfaden für detaillierte Anweisungen. Alternativ können Sie die Online-Plattform Code-Hero verwenden. Code-Hero bietet eine Online-IDE und ein Terminal mit allen vorinstallierten Werkzeugen, sodass Sie sofort mit dem Codieren beginnen können, ohne etwas installieren zu müssen.

Python REST API läuft in Code-Hero, direkt vom Browser aus zugänglichPython REST API läuft in Code-Hero, direkt vom Browser aus zugänglich

Erstellen eines neuen Projekts

Der erste Schritt besteht darin, ein neues Projektverzeichnis zu erstellen. Für diesen Leitfaden nennen wir es myRestApi:

mkdir myRestApi
cd myRestApi

Stellen Sie als Nächstes die Python-Version auf die neueste verfügbare Version mit asdf ein und initialisieren Sie das Git-Repository:

asdf install python latest \
  && asdf local python latest

echo "__pycache__/" >> .gitignore

git init
git add -A .
git commit -m "First commit"

Installation der Flask-Abhängigkeit

Für dieses Beispiel benötigen wir nur eine Abhängigkeit: Flask.

Flask ist ein leichtgewichtiges Web-Framework, das eine schnelle Entwicklung von Webanwendungen ermöglicht. Es ist darauf ausgelegt, einfach und benutzerfreundlich zu sein, sodass Entwickler schnell Webdienste erstellen und bereitstellen können. Die integrierte Unterstützung für Routing, Templating und die Verarbeitung von HTTP-Anfragen macht Flask zu einer ausgezeichneten Wahl für die Erstellung von REST-APIs.

Installieren Sie Flask (und python-dotenv) mit pip:

pip install Flask python-dotenv

Wir installieren hier die Module Flask und python-dotenv. Sie werden bald sehen, warum wir python-dotenv verwenden (Spoiler: Es dient zur Verwaltung von Umgebungsvariablen).

Nach der Installation frieren Sie die Paketversionen in einer requirements.txt-Datei ein:

pip freeze > requirements.txt

Das Einfrieren Ihrer Abhängigkeiten stellt sicher, dass Ihr Produktionsserver oder Ihre Kollegen dieselben Versionen wie Sie verwenden. Ein paar Sekunden Arbeit können viele zukünftige Kopfschmerzen vermeiden.

Implementierung der REST-API mit Flask

Lassen Sie uns nun in den Code eintauchen!

Erstellen Sie eine Datei namens app.py und fügen Sie den folgenden Code ein:

import os
from dotenv import load_dotenv
from flask import Flask, jsonify, request

# Laden von Umgebungsvariablen aus der .env-Datei, wenn nicht in Produktion
if os.environ.get('ENV') != 'production':
    load_dotenv()

# Erstellen der Flask-App
app = Flask(__name__)

# Beispiel-Datensatz
tasks = [
    {
        'id': 1,
        'title': 'Einkaufen',
        'description': 'Milch, Käse, Pizza, Früchte',
        'done': False
    },
    {
        'id': 2,
        'title': 'Python lernen',
        'description': 'Grundlagen der Python-Programmierung lernen',
        'done': False
    }
]

# Route '/api/tasks' (GET) zum Auflisten aller Aufgaben
@app.route('/api/tasks', methods=['GET'])
def get_tasks():
    return jsonify({'tasks': tasks})

# Route '/api/tasks/<task_id>' (GET) zum Abrufen einer bestimmten Aufgabe nach ihrer ID
@app.route('/api/tasks/<int:task_id>', methods=['GET'])
def get_task(task_id):
    task = [task for task in tasks if task['id'] == task_id]
    if len(task) == 0:
        return jsonify({'error': 'Aufgabe nicht gefunden'}), 404
    return jsonify({'task': task[0]})

# Route '/api/tasks' (POST) zum Erstellen einer neuen Aufgabe
@app.route('/api/tasks', methods=['POST'])
def create_task():
    if not request.json or 'title' not in request.json:
        return jsonify({'error': 'Titel ist erforderlich'}), 400
    task = {
        'id': tasks[-1]['id'] + 1,
        'title': request.json['title'],
        'description': request.json.get('description', ""),
        'done': False
    }
    tasks.append(task)
    return jsonify({'task': task}), 201

# Starten des API-Servers
if __name__ == '__main__':
    if os.environ.get('ENV') == 'production':
        app.run()
    else:
        app.run(host='0.0.0.0', port=8080, debug=True)

Um den Server zu starten, führen Sie aus:

python app.py

Mit der Option host='0.0.0.0' können Sie auch auf Ihre API zugreifen, indem Sie Ihren Browser verwenden, wenn Sie Code-Hero verwenden. Navigieren Sie einfach zu http://<XXXXXX>.stackhero-network.com:8080/api/tasks, wobei Sie <XXXXXX> durch Ihre Code-Hero-Domain ersetzen.

Testen Ihrer REST-API

Sobald der Server läuft, können Sie mit ihm über cURL interagieren. Hier sind einige Beispiele:

  • Alle Aufgaben abrufen:

    curl -s http://localhost:8080/api/tasks
{
  "tasks": [
    {
      "description": "Milch, Käse, Pizza, Früchte",
      "done": false,
      "id": 1,
      "title": "Einkaufen"
    },
    {
      "description": "Grundlagen der Python-Programmierung lernen",
      "done": false,
      "id": 2,
      "title": "Python lernen"
    }
  ]
}

  • Aufgabe mit ID 2 abrufen:

    curl -s http://localhost:8080/api/tasks/2
{
  "task": {
    "description": "Grundlagen der Python-Programmierung lernen",
    "done": false,
    "id": 2,
    "title": "Python lernen"
  }
}

  • Neue Aufgabe erstellen:

    curl -s -X POST -H "Content-Type: application/json" \
-d '{"title": "Neue Aufgabe", "description": "Erstellt mit cURL"}' \
http://localhost:8080/api/tasks
{
  "task": {
    "description": "Erstellt mit cURL",
    "done": false,
    "id": 3,
    "title": "Neue Aufgabe"
  }
}

Tipp: Leiten Sie die Ausgabe an jq weiter, um das JSON zu verschönern. Zum Beispiel erzeugt curl -s http://localhost:8080/api/tasks/2 | jq ein besser lesbares Ergebnis.

Beispiel einer Python REST API mit Flask, ausgeführt in Stackhero Code-Hero, mit dem Server (1) und dem Client, der cURL verwendet (2)Beispiel einer Python REST API mit Flask, ausgeführt in Stackhero Code-Hero, mit dem Server (1) und dem Client, der cURL verwendet (2)

Umgang mit Umgebungsvariablen

Umgebungsvariablen sind entscheidend für den Schutz sensibler Informationen, wie z.B. Datenbankanmeldedaten oder API-Schlüssel. Es gibt zwei Hauptvorteile bei der Verwendung von Umgebungsvariablen:

  1. Ihre Geheimnisse werden nicht in Ihrem Git-Repository gespeichert, was sicherstellt, dass Unbefugte nicht auf Ihre sensiblen Daten zugreifen können, selbst wenn sie Zugriff auf Ihren Quellcode erhalten.
  2. Sie können unterschiedliche Anmeldedaten für verschiedene Umgebungen verwenden (z.B. Produktion vs. Entwicklung).

Um Umgebungsvariablen zu verwalten, verwenden wir das Modul python-dotenv. Installieren Sie es zuerst, falls noch nicht geschehen:

pip install python-dotenv
pip freeze > requirements.txt

Erstellen Sie dann eine .env-Datei im Stammverzeichnis Ihres Projekts und fügen Sie Ihre Entwicklungsumgebungsvariablen hinzu. Zum Beispiel:

ENV="development"
DATABASE_PASSWORD="secretPassword"
THIRD_API_PRIVATE_KEY="secretKey"

Fügen Sie schließlich die .env-Datei zu Ihrer .gitignore hinzu, um die Sicherheit zu gewährleisten:

echo ".env" >> .gitignore

Um auf diese Umgebungsvariablen in Python zuzugreifen, verwenden Sie einfach os.environ.get():

import os

print(os.environ.get('ENV'))

Die .env-Datei wird nur für die Entwicklungsumgebung verwendet. Für Staging oder Produktion setzen Sie die Umgebungsvariablen im Stackhero-Dashboard in Ihrer Python-Service-Konfiguration.

Vorbereitung von Python und Flask für den Produktionseinsatz

Obwohl dieser Leitfaden den integrierten Entwicklungsserver von Flask verwendet, ist es für die Produktion unerlässlich, einen produktionsbereiten WSGI-Server wie Gunicorn zu verwenden. Befolgen Sie diese Schritte:

  1. Installieren Sie Gunicorn:

    pip install gunicorn
pip freeze > requirements.txt

  2. Starten Sie Ihre App mit Gunicorn mit dem Argument app:app (wobei das erste app der Dateiname und das zweite app die Flask-Instanz ist):

    ENV=production gunicorn app:app \
  --error-logfile - \
  -b 0.0.0.0:8080

  3. Erstellen Sie ein Makefile, um das Umschalten zwischen Entwicklungs- und Produktionsmodus zu vereinfachen:

    .DEFAULT_GOAL := dev

# Standardmäßig führt Stackhero für Python die Regel "run" aus. Wir überschreiben sie, um die 'prod'-Regel auszuführen.
run: prod

prod:
 	ENV=production gunicorn app:app \
 	  --error-logfile - \
 	  -b 0.0.0.0:8080

dev:
 	python app.py

Sie können Ihren Server im Entwicklungsmodus mit make dev (oder einfach make) und im Produktionsmodus mit make prod ausführen.

Bereitstellung Ihres Python-Codes in der Produktion

Der einfachste Weg, Ihr Python-Projekt bereitzustellen, ist die Verwendung des Stackhero Python Cloud Hosting Service. Zu den Hauptfunktionen gehören:

  • Bereitstellung mit einem einfachen git push
  • Anpassbare Domain mit automatischer TLS-Zertifikatsverwaltung (HTTPS)
  • Läuft auf einer privaten und dedizierten VM für maximale Sicherheit
  • Unterstützt HTTP/2, TLS 1.3 (HTTPS), WebSockets, GZIP & Brotli-Komprimierung, ETag und TCP/UDP-Portzugriff

Konfiguration des "Stackhero for Python"-Dienstes

Um Ihren Code auf Stackhero bereitzustellen, folgen Sie diesen Schritten:

  1. Rufen Sie Ihren öffentlichen Schlüssel ab, indem Sie Folgendes verwenden:

    cat ~/.ssh/id_*.pub

  2. Gehen Sie im Stackhero-Dashboard zu Ihrem "Stackhero for Python"-Dienst und klicken Sie auf die Schaltfläche "Konfigurieren".

  3. Kopieren Sie den öffentlichen Schlüssel aus dem ersten Schritt und fügen Sie ihn in das Feld "SSH public keys" oder "Key" ein.

  4. Validieren Sie die Konfiguration, indem Sie auf die Schaltfläche "Validieren" am unteren Rand der Seite klicken.

Konfiguration des öffentlichen Schlüssels "Stackhero for Python"Konfiguration des öffentlichen Schlüssels "Stackhero for Python"

Haben Sie keine SSH-Schlüssel? Erstellen Sie sie, indem Sie Folgendes ausführen:

ssh-keygen -t ed25519

Konfigurieren Sie schließlich Ihr Repository, um auf Stackhero bereitzustellen. Fügen Sie in Ihrem Projektordner ein Git-Remote mit dem in Ihrem Stackhero-Dienst bereitgestellten Befehl hinzu (ersetzen Sie <XXXXXX> durch Ihre Dienst-Domain):

git remote add stackhero ssh://stackhero@<XXXXXX>.stackhero-network.com:222/project.git

Git-Remote-BefehlGit-Remote-Befehl

Bereitstellung in der Produktion

Sobald alles konfiguriert ist, stellen Sie Ihren Code mit einem einzigen Befehl in der Produktion bereit:

git push stackhero main

Stellen Sie sicher, dass Sie Ihre Änderungen hinzufügen und committen, bevor Sie Ihren Code in der Produktion bereitstellen. In Stackhero Code-Hero können Sie Änderungen schnell mit der Befehlspalette committen (drücken Sie Ctrl+Shift+P auf Windows/Linux oder Cmd+Shift+P auf macOS und geben Sie Git: Commit ein).

Nach der Bereitstellung besuchen Sie Ihre API-URL unter https://<XXXXXX>.stackhero-network.com/api/tasks (ersetzen Sie <XXXXXX> durch Ihre Dienst-Domain), um Ihre Flask-API in Aktion zu sehen.

Fazit

Indem Sie diesem Leitfaden folgen, verstehen Sie nun, wie man eine REST-API mit Flask erstellt. Mit diesem Wissen können Sie Ihre RESTful-Anwendungen sicher entwickeln und erweitern und sie mit verschiedenen Frontend- und Backend-Diensten integrieren.

Other articles for Python