Bauen Sie Ihre erste API mit Flask

Einführung

Der Aufbau einer robusten RESTful API ist für moderne Webanwendungen unerlässlich und ermöglicht eine nahtlose Kommunikation zwischen Diensten und Clients. In diesem umfassenden Leitfaden erfahren Sie, wie Sie Ihre erste API mit Flask - einem leichtgewichtigen und dennoch leistungsstarken Python-Webframework - erstellen, sichern und bereitstellen können. Wir werden eine reale Beispiel-API erstellen, die Produktdaten für ein E-Commerce-Szenario bereitstellt, und fortgeschrittene Funktionen wie Fehlerbehandlung, CRUD-Operationen, Datenbankintegration, Authentifizierung, Modularisierung mit Blueprints, API-Dokumentation, Testen und Bereitstellungsstrategien behandeln.

Erforderliche Pakete importieren

Um unseren Code übersichtlich zu halten und Wiederholungen zu vermeiden, importieren wir zunächst die erforderlichen Pakete. Dadurch wird sichergestellt, dass alle nachfolgenden Codeblöcke Zugriff auf die erforderlichen Bibliotheken haben.

# Importieren Sie die für die API-Entwicklung erforderlichen Bibliotheken.
from flask import Flask, jsonify, request, abort

Erstellen einer einfachen Flask-API mit realen Beispieldaten

Wir werden eine einfache API erstellen, die Produktdaten für ein E-Commerce-Beispiel bereitstellt. Dazu gehören ein Willkommens-Endpunkt und ein /api/products-Endpunkt, der eine Liste von Produkten zurückgibt.

Grundlegendes API-Beispiel

# Initialisieren Sie die Flask-Anwendung.
app = Flask(__name__)

# Definieren des Root-Endpunkts.
@app.route("/")
def index():
    return jsonify({"message": "Welcome to the Products API"})

# Definieren Sie einen Endpunkt, der eine Liste von Produkten zurückgibt.
@app.route("/api/products", methods=["GET"])
def get_products():
    # Beispiel für Produktdaten aus der realen Welt.
    products = [
        {"id": 1, "name": "Wireless Mouse", "price": 29.99, "category": "Electronics"},
        {"id": 2, "name": "Bluetooth Headphones", "price": 59.99, "category": "Electronics"},
        {"id": 3, "name": "Coffee Maker", "price": 79.99, "category": "Home Appliances"},
        {"id": 4, "name": "Electric Kettle", "price": 39.99, "category": "Home Appliances"},
        {"id": 5, "name": "Smartphone Stand", "price": 19.99, "category": "Accessories"}
    ]
    return jsonify({"products": products})

if __name__ == "__main__":
    # Führen Sie die Anwendung auf Port 5000 mit aktiviertem Debugging aus.
    app.run(debug=True, port=5000)

Ausführen und Testen der API

Um Ihre Flask-API auszuführen, führen Sie Ihr Skript z. B. mit python api.py aus. Stellen Sie sicher, dass Ihre API auf einem bestimmten Port (z. B. 5000) ausgeführt wird, um Konsistenz zu gewährleisten. Beispiel:

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

Dieser Befehl startet den Flask-Entwicklungsserver auf Port 5000 mit aktiviertem Debugging.

Hinweis

Sobald Ihre API ausgeführt wird, können Sie auf sie zugreifen, indem Sie http://localhost:5000/ in Ihrem Webbrowser aufrufen.

Testen Ihrer API

Sie können Ihre API mit Tools wie cURL oder Postman testen.

cURL verwenden:

curl http://127.0.0.1:5000/
curl http://127.0.0.1:5000/api/products

Postman verwenden:
- Senden Sie eine GET-Anfrage an http://127.0.0.1:5000/api/products, um die JSON-Antwort mit den Produktdaten anzuzeigen.

Fehlerbehandlung und Eingabevalidierung

Eine robuste Fehlerbehandlung ist für eine produktionsreife API entscheidend. Hier fügen wir Fehlerbehandlungen und Eingabevalidierung hinzu, um sicherzustellen, dass unsere API angemessen auf unerwartete Eingaben und Fehler reagiert.

Beispiel für Fehlerbehandlung

from flask import abort

@app.route("/api/divide", methods=["GET"])
def divide():
    try:
        a = float(request.args.get("a", ""))
        b = float(request.args.get("b", ""))
        if b == 0:
            abort(400, description="Division by zero is not allowed.")
        return jsonify({"result": a / b})
    except ValueError:
        abort(400, description="Invalid input. Please provide numeric values.")

@app.errorhandler(400)
def bad_request(error):
    response = jsonify({"error": error.description})
    response.status_code = 400
    return response

CRUD-Operationen

Die Verwaltung von Ressourcen durch CRUD-Operationen (Erstellen, Lesen, Aktualisieren, Löschen) ist unerlässlich. Nachfolgend ein einfaches Beispiel mit einem In-Memory-Datenspeicher für die Produktverwaltung.

CRUD-Beispiel

# In-Memory-Datenspeicher für Produkte.
items = []

# Ein neues Produkt erstellen.
@app.route("/api/items", methods=["POST"])
def create_item():
    data = request.get_json()
    items.append(data)
    return jsonify({"message": "Item created", "item": data}), 201

# Alle Produkte lesen.
@app.route("/api/items", methods=["GET"])
def get_items():
    return jsonify({"items": items})

# Ein Produkt aktualisieren.
@app.route("/api/items/<int:item_id>", methods=["PUT"])
def update_item(item_id):
    data = request.get_json()
    if item_id < 0 or item_id >= len(items):
        abort(404, description="Item not found")
    items[item_id].update(data)
    return jsonify({"message": "Item updated", "item": items[item_id]})

# Ein Produkt löschen.
@app.route("/api/items/<int:item_id>", methods=["DELETE"])
def delete_item(item_id):
    if item_id < 0 or item_id >= len(items):
        abort(404, description="Item not found")
    deleted_item = items.pop(item_id)
    return jsonify({"message": "Item deleted", "item": deleted_item})

Datenbank-Integration

Für produktive Anwendungen ist die Integration einer Datenbank unerlässlich. Flask kann mit Hilfe eines ORM wie SQLAlchemy problemlos mit Datenbanken verbunden werden.

Beispiel für die SQLAlchemy-Integration

# Konfigurieren Sie die SQLite-Datenbank.
from flask_sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///api.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

# Definieren Sie ein einfaches Modell für Produkte.
class Product(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80), nullable=False)
    price = db.Column(db.Float, nullable=False)
    category = db.Column(db.String(80), nullable=False)

# Erstellen Sie die Datenbanktabellen.
with app.app_context():
    db.create_all()

# Endpunkt zum Hinzufügen eines Produkts zur Datenbank.
@app.route("/api/db/products", methods=["POST"])
def add_product():
    data = request.get_json()
    new_product = Product(name=data.get("name"), price=data.get("price"), category=data.get("category"))
    db.session.add(new_product)
    db.session.commit()
    return jsonify({"message": "Product added", "product": {"id": new_product.id, "name": new_product.name}}), 201

Authentifizierung und Autorisierung

Die Absicherung Ihrer API ist entscheidend. Nachfolgend ein einfaches Beispiel mit JWT für die Authentifizierung.

Beispiel für JWT-Authentifizierung

from flask_jwt_extended import JWTManager, create_access_token, jwt_required, get_jwt_identity

# JWT konfigurieren.
app.config["JWT_SECRET_KEY"] = "your-secret-key"
jwt = JWTManager(app)

@app.route("/api/login", methods=["POST"])
def login():
    username = request.json.get("username", None)
    password = request.json.get("password", None)
    # Verwenden Sie zur Demonstration einen festen Benutzernamen und ein Passwort.
    if username != "admin" or password != "password":
        abort(401, description="Invalid credentials")
    access_token = create_access_token(identity=username)
    return jsonify(access_token=access_token)

@app.route("/api/protected", methods=["GET"])
@jwt_required()
def protected():
    current_user = get_jwt_identity()
    return jsonify(logged_in_as=current_user)

Modularisierung mit Blueprints

Bei größeren Anwendungen hilft die Organisation des Codes in Blueprints, eine saubere Struktur zu erhalten. Mit Blueprints können Sie verwandte Endpunkte zusammenfassen.

Blueprint-Beispiel

from flask import Blueprint

# Erstellen Sie einen Blueprint für produktbezogene Endpunkte.
products_bp = Blueprint('products', __name__)

@products_bp.route("/api/blueprint/products", methods=["GET"])
def blueprint_get_products():
    return jsonify({"products": items})

# Registrieren des Blueprints mit der Flask-Anwendung.
app.register_blueprint(products_bp)

API-Dokumentation

Interaktive API-Dokumentation ist für produktionsreife APIs unerlässlich. Werkzeuge wie Flasgger können automatisch Swagger-Dokumentation generieren.

Beispiel für Flasgger-Setup

from flasgger import Swagger

# Initialisieren Sie Swagger für die API-Dokumentation.
swagger = Swagger(app)

@app.route("/api/docs")
def api_docs():
    return jsonify({"message": "Visit /apidocs for the interactive API documentation."})

Testen und Bereitstellen

Testen der API

Automatisierte Tests stellen sicher, dass Ihre API zuverlässig bleibt. Zum Beispiel mit pytest:

def test_index():
    response = app.test_client().get("/")
    assert response.status_code == 200
    assert b"Welcome" in response.data

Ausführen der API

Führen Sie Ihre Flask-Anwendung auf Port 5000 aus, indem Sie den folgenden Befehl eingeben:

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

Strategien für die Bereitstellung

Für den Einsatz in der Produktion sollten Sie die folgenden Strategien in Betracht ziehen:

Verwenden Sie einen WSGI-Produktionsserver:
Bereitstellen Ihrer Flask-Anwendung mit Gunicorn:
```
gunicorn --bind 0.0.0.0:5000 your_script:app
```
Containerisierung:
Verwenden Sie Docker zur Containerisierung Ihrer Anwendung. Erstellen Sie zum Beispiel ein Dockerfile:
```
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "your_script:app"]
```
Ersetzen Sie your_script durch den Namen Ihrer Python-Datei, die die Flask-Anwendung enthält.
Orchestrierung:
Für die Skalierung und Verwaltung sollten Sie Kubernetes oder ähnliche Orchestrierungstools verwenden.

Flussdiagramm für die Bereitstellung

flowchart LR
    A[Develop API] --> B[Write Tests]
    B --> C[Containerize with Docker]
    C --> D[Deploy with Gunicorn]
    D --> E[Orchestrate with Kubernetes]
    E --> F[Monitor & Scale]

Schlussfolgerung

Anhand dieses umfassenden Leitfadens haben Sie gelernt, wie Sie mit Flask eine produktionsreife RESTful-API anhand von realen Beispieldaten erstellen können. Wir haben API-Erstellung, Fehlerbehandlung, CRUD-Vorgänge, Datenbankintegration, Authentifizierung, Modularisierung mit Blueprints, API-Dokumentation, Testen und Bereitstellungsstrategien behandelt. Mit diesen Techniken können Sie robuste, sichere und skalierbare APIs für reale Anwendungen erstellen.

Weiterführende Literatur

Viel Spaß beim Programmieren und beim Erstellen und Bereitstellen Ihrer produktionsreifen API mit Flask!

Wiederverwendung

CC BY-NC-SA 4.0

Zitat

Mit BibTeX zitieren:

@online{kassambara2024,
  author = {Kassambara, Alboukadel},
  title = {Bauen Sie Ihre erste API mit Flask},
  date = {2024-02-08},
  url = {https://www.datanovia.com/de/learn/programming/python/tools/build-your-first-api-with-flask.html},
  langid = {de}
}

Bitte zitieren Sie diese Arbeit als:

Kassambara, Alboukadel. 2024. “Bauen Sie Ihre erste API mit Flask.” February 8, 2024. https://www.datanovia.com/de/learn/programming/python/tools/build-your-first-api-with-flask.html.