So erstellen Sie RESTful-APIs mit Flask und Python

RESTful APIs sind in der modernen Entwicklung unverzichtbar und ermöglichen die effiziente und skalierbare Kommunikation verschiedener Systeme. Python bietet mit seinem Flask-Framework einen einfachen und leistungsstarken Ansatz zur Erstellung von APIs. In diesem Leitfaden erfahren Sie, wie Sie mit Flask eine RESTful-API erstellen und dabei alles von den Grundlagen bis zur Authentifizierung und Nutzung mit HTTP-Clients abdecken.

Was ist eine RESTful-API?

Bevor wir mit dem Code beginnen, ist es wichtig zu verstehen, was eine RESTful API ist. API (Application Programming Interface) ist eine Reihe von Regeln, die es einer Software ermöglichen, mit einer anderen zu kommunizieren. Der REST (Representational State Transfer)-Stil definiert eine Reihe von Prinzipien, denen die API folgen muss:

• Client-Server: Trennung zwischen dem Client (der die API nutzt) und dem Server (der die Daten bereitstellt).
• Zustandslos: Jede vom Client gestellte Anfrage muss alle Informationen enthalten, die der Server zur Verarbeitung benötigt.
• Cachebar: API-Antworten können zwischengespeichert werden, um die Leistung zu verbessern.
• Einheitliche Schnittstelle: Die Kommunikation zwischen Client und Server muss auf standardisierte Weise erfolgen, unter Verwendung von HTTP-Methoden wie GET, POST, PUT und DELETE.

Erstellen einer RESTful-API mit Flask

Jetzt erstellen wir eine einfache API, die eine Liste von Benutzern verwaltet. Mit der API können Sie Benutzer hinzufügen, bearbeiten, anzeigen und löschen.

1. Flasche installieren

Stellen Sie zunächst sicher, dass Flask installiert ist. Wenn nicht, können Sie es mit pip:
installieren

pip install Flask

2. Projektstruktur

Unser Projekt wird die folgende Struktur haben:

/api_flask
│
├── app.py
└── requirements.txt

3. Flask konfigurieren

In der app.py-Datei importieren wir zunächst die erforderlichen Bibliotheken und konfigurieren unsere Flask-Anwendung:

from flask import Flask, jsonify, request

app = Flask(__name__)

# Dados simulados
users = [
    {'id': 1, 'name': 'Alice', 'email': 'alice@example.com'},
    {'id': 2, 'name': 'Bob', 'email': 'bob@example.com'}
]

4. Endpunkte erstellen

Jetzt erstellen wir unsere Endpunkte zum Ansehen, Hinzufügen, Aktualisieren und Löschen von Benutzern.

4.1. Endpunkt zum Auflisten von Benutzern

Wir verwenden die Methode GET, um alle Benutzer aufzulisten:

@app.route('/users', methods=['GET'])
def get_users():
    return jsonify(users), 200

4.2. Endpunkt zum Abrufen eines bestimmten Benutzers

Wir verwenden die Methode GET mit der Benutzer-ID, um Details zu einem bestimmten Benutzer abzurufen:

@app.route('/users/<user_id>', methods=['GET'])
def get_user(user_id):
    user = next((user for user in users if user['id'] == user_id), None)
    if user:
        return jsonify(user), 200
    else:
        return jsonify({'message': 'User not found'}), 404
</user_id>

4.3. Endpunkt zum Erstellen eines neuen Benutzers

Die Methode POST wird zum Hinzufügen eines neuen Benutzers verwendet. Der Client sendet die Daten im JSON-Format.

@app.route('/users', methods=['POST'])
def create_user():
    data = request.get_json()
    new_user = {
        'id': len(users) + 1,
        'name': data['name'],
        'email': data['email']
    }
    users.append(new_user)
    return jsonify(new_user), 201

4.4. Endpunkt zum Aktualisieren eines Benutzers

Hier verwenden wir die Methode PUT, um die Daten eines bestehenden Benutzers zu aktualisieren:

@app.route('/users/<user_id>', methods=['PUT'])
def update_user(user_id):
    data = request.get_json()
    user = next((user for user in users if user['id'] == user_id), None)
    if user:
        user['name'] = data['name']
        user['email'] = data['email']
        return jsonify(user), 200
    else:
        return jsonify({'message': 'User not found'}), 404
</user_id>

4.5. Endpunkt zum Löschen eines Benutzers

Wir verwenden die Methode DELETE, um einen Benutzer zu entfernen:

@app.route('/users/<user_id>', methods=['DELETE'])
def delete_user(user_id):
    global users
    users = [user for user in users if user['id'] != user_id]
    return jsonify({'message': 'User deleted'}), 200
</user_id>

5. Ausführen der API

Jetzt führen Sie einfach unsere Anwendung aus:

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

Wenn Sie die Datei app.py ausführen, ist unsere API unter http://127.0.0.1:5000/users verfügbar.

6. Authentifizierung mit Flask

Um unserer API eine Sicherheitsebene hinzuzufügen, können wir JWT (JSON Web Token) verwenden. Mit JWT können wir sicherstellen, dass nur authentifizierte Benutzer auf bestimmte Endpunkte zugreifen können.

6.1. Flask-JWT-Extended installieren

Installieren Sie die erforderliche Erweiterung:

pip install Flask-JWT-Extended

6.2. JWT konfigurieren

Aktualisieren Sie Ihre app.py-Datei, um die JWT-Authentifizierung einzuschließen:

from flask_jwt_extended import JWTManager, create_access_token, jwt_required

app.config['JWT_SECRET_KEY'] = 'your-secret-key'  # Troque pela sua chave secreta
jwt = JWTManager(app)

# Login para obter o token
@app.route('/login', methods=['POST'])
def login():
    data = request.get_json()
    if data['username'] == 'admin' and data['password'] == 'admin':
        access_token = create_access_token(identity={'username': 'admin'})
        return jsonify(access_token=access_token), 200
    else:
        return jsonify({'message': 'Invalid credentials'}), 401

# Exemplo de endpoint protegido
@app.route('/protected', methods=['GET'])
@jwt_required()
def protected():
    return jsonify({'message': 'Access granted to protected endpoint'}), 200

Jetzt muss beim Zugriff auf den /protected-Endpunkt das JWT-Token im Anforderungsheader gesendet werden, um den Benutzer zu authentifizieren.

7. Nutzung der API mit HTTP-Client

Um die API zu nutzen, können wir Tools wie Postman oder Bibliotheken wie requests in Python verwenden.

Beispiel für die Nutzung der API mithilfe von Anfragen:

import requests

# Consumindo o endpoint de listagem de usuários
response = requests.get('http://127.0.0.1:5000/users')
print(response.json())

Abschluss

Das Erstellen einer RESTful-API mit Flask ist unkompliziert und flexibel. Flask bietet ein minimalistisches Framework, das um Funktionen wie Authentifizierung, Fehlerbehandlung und andere Sicherheitsebenen erweitert werden kann. Durch die Befolgung von REST-Prinzipien und guten Entwicklungspraktiken ist es möglich, mit Python effiziente und skalierbare APIs zu erstellen.

Jetzt können Sie mit Flask Ihre eigene RESTful-API erstellen und diese an Ihre Bedürfnisse und Anforderungen anpassen.

Das obige ist der detaillierte Inhalt vonSo erstellen Sie RESTful-APIs mit Flask und Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!