Python: Erstellung einer REST API

Schritt-für-Schritt-Anleitung zum Aufbau einer REST API mit Flask in Python

👋 Willkommen in der Stackhero-Dokumentation!

Stackhero bietet eine einsatzbereite Python Cloud-Lösung, die Ihren Deployment-Prozess vereinfacht:

Deployen Sie Ihre Anwendung in die Produktion in Sekunden mit einem einfachen git push.

Verwenden Sie Ihre eigene Domain, mit automatischer HTTPS-Zertifikatskonfiguration – sichere Verbindungen werden für Sie eingerichtet.

Profitieren Sie von automatischen Backups, One-Click-Updates und planbaren Kosten, damit Sie sich auf Ihren Code konzentrieren können, nicht auf das Infrastrukturmanagement.

Nutzen Sie starke Performance und Sicherheit auf einer privaten, dedizierten Infrastruktur. Ihre Umgebung ist isoliert und geschützt.

Sparen Sie Zeit und vereinfachen Sie Ihren Workflow: Ihr Code läuft mit Stackheros Python Cloud Hosting in nur 5 Minuten.

Diese Anleitung zeigt Ihnen, wie Sie mit Python und Flask eine einfache REST API erstellen. Flask ist ein leichtgewichtiges Micro-Framework, das die schnelle Entwicklung von Webanwendungen und APIs ermöglicht.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie die folgenden Tools installiert haben:

Python
pip
git
asdf

Wenn Sie Hilfe bei der Einrichtung Ihrer Umgebung benötigen, lesen Sie den Leitfaden zur Development platform. Alternativ können Sie direkt mit der Online-Plattform Code-Hero loslegen. Code-Hero bietet eine Online-IDE und ein Terminal, in dem alle wichtigen Tools bereits vorinstalliert sind. So können Sie sich auf Ihren Code konzentrieren, statt Zeit mit Installation und Einrichtung zu verbringen.

Python REST API läuft in Code-Hero, direkt über den Browser zugänglich

Ein neues Projekt erstellen

Beginnen Sie mit dem Anlegen eines neuen Projektverzeichnisses. In diesem Beispiel heißt das Projekt myRestApi:

mkdir myRestApi
cd myRestApi

Setzen Sie die Python-Version mit asdf auf die neueste verfügbare Version und initialisieren Sie ein Git-Repository:

asdf install python latest \
  && asdf local python latest

echo "__pycache__/" >> .gitignore

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

Flask-Abhängigkeit installieren

Für dieses Beispiel benötigen Sie nur eine Hauptabhängigkeit: Flask.

Flask ist darauf ausgelegt, einfach und schnell zu sein, sodass Sie Web-APIs ohne unnötigen Overhead entwickeln und bereitstellen können. Es bietet integrierte Unterstützung für Routing, Templating und HTTP-Request-Handling, sodass Sie in wenigen Minuten von der Idee zur funktionierenden API gelangen.

Sie können Flask und python-dotenv mit pip installieren:

pip install Flask python-dotenv

Wir fügen python-dotenv hinzu, um Umgebungsvariablen sicher und komfortabel zu verwalten. Die Verwendung sehen Sie in den nächsten Schritten.

Nach der Installation sollten Sie Ihre Abhängigkeiten in einer requirements.txt Datei einfrieren:

pip freeze > requirements.txt

Das Einfrieren der Abhängigkeiten stellt sicher, dass alle dieselben Paketversionen verwenden. Dieser kleine Schritt kann Ihnen später viele Stunden Fehlersuche ersparen.

Die REST API mit Flask implementieren

Jetzt können Sie mit dem Schreiben Ihres API-Codes beginnen.

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

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

# Umgebungsvariablen aus .env für Nicht-Produktivumgebungen laden
if os.environ.get('ENV') != 'production':
    load_dotenv()

app = Flask(__name__)

# Beispiel-Daten für Aufgaben
tasks = [
    {
        'id': 1,
        'title': 'Buy groceries',
        'description': 'Milk, Cheese, Pizza, Fruits',
        'done': False
    },
    {
        'id': 2,
        'title': 'Learn Python',
        'description': 'Learn Python programming basics',
        'done': False
    }
]

@app.route('/api/tasks', methods=['GET'])
def get_tasks():
    return jsonify({'tasks': tasks})

@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 not task:
        return jsonify({'error': 'Task not found'}), 404
    return jsonify({'task': task[0]})

@app.route('/api/tasks', methods=['POST'])
def create_task():
    if not request.json or 'title' not in request.json:
        return jsonify({'error': 'Title is required'}), 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

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

Sie können den Server mit folgendem Befehl starten:

python app.py

Mit host='0.0.0.0' ist Ihre API im Browser erreichbar, wenn Sie Code-Hero verwenden. Rufen Sie http://<XXXXXX>.stackhero-network.com:8080/api/tasks auf und ersetzen Sie <XXXXXX> durch Ihre Code-Hero-Domain.

Ihre REST API testen

Sobald der Server läuft, können Sie mit cURL auf Ihre API zugreifen. Hier einige Beispielbefehle:

Alle Aufgaben abrufen:

curl -s http://localhost:8080/api/tasks
# Output:
# {
#   "tasks": [
#     ...
#   ]
# }

Eine bestimmte Aufgabe abrufen (ID 2):

curl -s http://localhost:8080/api/tasks/2
# Output:
# {
#   "task": {
#     ...
#   }
# }

Eine neue Aufgabe erstellen:

curl -s -X POST -H "Content-Type: application/json" \
-d '{"title": "New task", "description": "Created with cURL"}' \
http://localhost:8080/api/tasks
# Output:
# {
#   "task": {
#     ...
#   }
# }

Tipp: Für eine übersichtlichere Ausgabe können Sie das Ergebnis an jq übergeben. Zum Beispiel macht curl -s http://localhost:8080/api/tasks/2 | jq das JSON leichter lesbar.

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

Umgang mit Umgebungsvariablen

Umgebungsvariablen helfen Ihnen, sensible Daten wie Datenbank-Passwörter oder API-Keys zu schützen. Sie halten vertrauliche Informationen aus dem Quellcode und der Git-Historie heraus und ermöglichen es, für jede Umgebung eigene Einstellungen zu verwenden.

Zur Verwaltung von Umgebungsvariablen können Sie das Modul python-dotenv nutzen. Falls Sie es zuvor nicht installiert haben, holen Sie dies jetzt nach:

pip install python-dotenv
pip freeze > requirements.txt

Erstellen Sie eine .env-Datei im Projektstammverzeichnis und fügen Sie Ihre Entwicklungsvariablen hinzu:

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

Fügen Sie .env zu Ihrer .gitignore hinzu, damit diese Datei nicht ins Git-Repository gelangt:

echo ".env" >> .gitignore

Sie können auf diese Variablen in Python mit os.environ.get() zugreifen:

import os

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

Die .env-Datei ist nur für die Entwicklung gedacht. Für Produktion oder Staging können Sie Umgebungsvariablen direkt im Stackhero-Dashboard unter der Python-Service-Konfiguration setzen.

Python und Flask für den Produktivbetrieb vorbereiten

Der integrierte Server von Flask eignet sich hervorragend für die Entwicklung. Für den Produktivbetrieb empfiehlt sich jedoch ein robuster WSGI-Server wie Gunicorn. So bereiten Sie Ihr Projekt vor:

Installieren Sie Gunicorn:

pip install gunicorn
pip freeze > requirements.txt

Starten Sie Ihre App mit Gunicorn:
```
ENV=production gunicorn app:app \
  --error-logfile - \
  -b 0.0.0.0:8080
```
Hierbei steht app:app für Ihre Datei (app.py) und die Flask-Anwendung (app).

Sie können ein Makefile hinzufügen, um einfach zwischen Entwicklungs- und Produktionsmodus zu wechseln:

.DEFAULT_GOAL := dev

# Stackhero for Python führt standardmäßig das "run"-Ziel aus. Wir überschreiben es, um 'prod' zu starten.
run: prod

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

dev:
	python app.py

Sie können den Server im Entwicklungsmodus mit make dev (oder einfach make) starten oder im Produktionsmodus mit make prod.

Ihren Python-Code in Produktion deployen

Stackhero macht das Cloud-Deployment einfach und sicher. Sie können Ihr Python-Projekt mit dem Python cloud hosting service bereitstellen. Zu den Features gehören:

Deployment mit nur einem git push
Automatisches TLS (HTTPS) mit anpassbaren Domains
Dedizierte Infrastruktur für Sicherheit
Unterstützung für HTTP/2, TLS 1.3, WebSockets, GZIP & Brotli, ETag sowie TCP/UDP-Portzugriff

Die "Stackhero for Python"-Service konfigurieren

Gehen Sie für das Deployment wie folgt vor:

Rufen Sie Ihren öffentlichen SSH-Schlüssel ab:
```
cat ~/.ssh/id_*.pub
```
Öffnen Sie im Stackhero-Dashboard Ihren "Stackhero for Python"-Service und wählen Sie "Configure".
Fügen Sie Ihren öffentlichen Schlüssel in das Feld "SSH public keys" oder "Key" ein.
Klicken Sie auf "Validate", um Ihre Konfiguration zu bestätigen.

"Stackhero for Python" Public-Key-Konfiguration

Falls Sie noch keine SSH-Schlüssel haben, können Sie diese mit folgendem Befehl generieren:
ssh-keygen -t ed25519

Fügen Sie Ihrem Projekt ein Git-Remote mit dem in Ihrem Stackhero-Service angegebenen Befehl hinzu (ersetzen Sie <XXXXXX> durch Ihre Service-Domain):

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

Git-Remote-Befehl

Deployment in Produktion

Wenn Sie bereit sind, deployen Sie Ihren Code mit:

git push stackhero main

Denken Sie daran, Ihre Änderungen vor dem Deployment zu committen. In Stackhero Code-Hero können Sie die Command Palette (Ctrl+Shift+P oder Cmd+Shift+P) nutzen und Git: Commit eingeben, um schnell zu committen.

Nach dem Deployment ist Ihre API unter https://<XXXXXX>.stackhero-network.com/api/tasks erreichbar. Ersetzen Sie <XXXXXX> durch Ihre Service-Domain, um auf Ihre Flask-API zuzugreifen.

Fazit

Sie haben nun eine funktionierende REST API mit Flask erstellt. Auf dieser Basis können Sie Ihre Anwendung problemlos erweitern, an Datenbanken anbinden oder mit anderen Diensten integrieren. Flask bietet Ihnen die Flexibilität, von einem einfachen Prototypen zu einer vollwertigen Produktions-API zu wachsen.