Microservice realisiert mit Flask

Technologien und Anforderungen an eine Integration in einer Digitalisierungsstrategie

Microservices vs. ESB Ansätzen

Ein Microservice ist eine Art der Softwarearchitektur, bei der eine Anwendung als eine Sammlung kleiner, unabhängiger Services entwickelt und betrieben wird, die jeweils einen bestimmten Teil der Funktionalität der Anwendung abdecken. Jeder Microservice läuft in seiner eigenen Prozessumgebung und kommuniziert über eine leichtgewichtige Mechanismen wie APIs oder Messaging-Protokolle mit anderen Services.

Im Vergleich zu einem Enterprise Services Bus (ESB), der oft als zentralisiertes, schwerfälliges System zur Integration von Anwendungen und Services eingesetzt wird, bietet die Microservices-Architektur einige Vorteile:

  • Skalierbarkeit: Da jeder Microservice separat betrieben wird, können einzelne Services unabhängig voneinander skaliert werden, um auf Änderungen im Anwendungsverkehr zu reagieren.

  • Flexibilität: Microservices ermöglichen es Entwicklern, schnell und unabhängig voneinander neue Funktionen hinzuzufügen oder zu ändern, ohne dass dies Auswirkungen auf andere Teile der Anwendung hat.

  • Zuverlässigkeit: Durch die Verwendung von leichtgewichtigen Kommunikationsmechanismen und die Begrenzung der Verantwortung jedes Services auf eine bestimmte Funktion, können Fehler in einem Service isoliert und schnell behoben werden, ohne dass die gesamte Anwendung betroffen ist.

  • Bessere Wartbarkeit: Da jeder Microservice eine klare Schnittstelle hat und nur eine begrenzte Verantwortung trägt, ist es einfacher, die Anwendung zu verstehen, zu warten und zu testen.

  • Technologische Vielfalt: Da jeder Service separat entwickelt und betrieben wird, können verschiedene Technologien und Frameworks innerhalb einer Anwendung verwendet werden, was die Flexibilität und die Fähigkeit zur Nutzung von neueren Technologien erhöht.

Es ist jedoch wichtig zu beachten, dass die Implementierung von Microservices eine sorgfältige Planung und Koordination erfordert, um sicherzustellen, dass die Vorteile dieser Architektur vollständig genutzt werden können.

Framework Flask

Flask ist ein leichtgewichtiges Web-Framework für Python, das Entwicklern ermöglicht, schnell und einfach Webanwendungen zu erstellen. Flask wurde von Armin Ronacher entwickelt und ist ein Microframework, das auf Werkzeugen wie Jinja2 und Werkzeug aufbaut.

Flask bietet eine Vielzahl von Funktionen und Vorteilen, darunter:

  • Einfache und intuitive Syntax: Flask ist einfach zu erlernen und zu verwenden, da es eine minimalistische Syntax und eine klar strukturierte Architektur hat.

  • Flexibilität: Flask ist sehr flexibel und kann leicht an unterschiedliche Anforderungen angepasst werden. Es erlaubt eine Vielzahl von Erweiterungen und kann nahtlos mit anderen Tools und Bibliotheken integriert werden.

  • Skalierbarkeit: Flask ist sehr skalierbar und kann leicht auf Anwendungen jeder Größe angepasst werden. Es kann horizontal oder vertikal skaliert werden und ist in der Lage, eine große Anzahl von Anfragen zu bearbeiten.

  • Unterstützung für RESTful-APIs: Flask unterstützt RESTful-APIs und ermöglicht es Entwicklern, schnell und einfach API-Endpunkte zu erstellen und zu verwalten.

  • Gute Dokumentation: Flask hat eine umfangreiche und gut strukturierte Dokumentation, die es Entwicklern erleichtert, das Framework zu verstehen und effektiv zu nutzen.

  • Unterstützung für Test-Driven-Development (TDD): Flask unterstützt TDD und erleichtert es Entwicklern, automatisierte Tests für ihre Anwendungen zu schreiben und zu integrieren.

  • Community-Unterstützung: Flask hat eine aktive und wachsende Community, die ständig neue Erweiterungen und Plugins entwickelt und pflegt. Dadurch können Entwickler von der Arbeit anderer profitieren und auf eine breite Palette von Tools und Bibliotheken zurückgreifen.

Zusammenfassend ist Flask ein flexibles, einfach zu erlernendes und dennoch leistungsstarkes Framework für die Entwicklung von Webanwendungen mit Python. Es bietet eine Vielzahl von Funktionen und Vorteilen, die es Entwicklern ermöglichen, schnell und einfach skalierbare, robuste und wartbare Anwendungen zu erstellen.

Installieren von Flask

Um Flask zu installieren, müssen Sie zunächst sicherstellen, dass Python auf Ihrem Computer installiert ist. Flask unterstützt Python-Versionen ab 3.6.

Hier sind die Schritte, um Flask zu installieren:

  1. Öffnen Sie ein Terminal oder eine Eingabeaufforderung.

  2. Stellen Sie sicher, dass pip, das Paketverwaltungssystem für Python, auf Ihrem Computer installiert ist. Geben Sie dazu pip --version ein, um zu überprüfen, ob pip installiert ist. Wenn pip nicht installiert ist, können Sie es mithilfe von python -m ensurepip --default-pip installieren.

  3. Geben Sie den folgenden Befehl ein, um Flask mithilfe von pip zu installieren:

pip install Flask

Dies installiert die neueste Version von Flask und alle erforderlichen Abhängigkeiten.

  1. Sobald die Installation abgeschlossen ist, können Sie die Installation überprüfen, indem Sie ein neues Python-Skript erstellen und den folgenden Code hinzufügen:

 

from flask import Flask
app = Flask(__name__)

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

Speichern Sie das Skript als app.py und führen Sie es aus, indem Sie den folgenden Befehl im Terminal eingeben:

python app.py
  1. Öffnen Sie einen Webbrowser und navigieren Sie zu http://localhost:5000/. Wenn alles richtig installiert wurde, sollten Sie die Nachricht „Hello, World!“ sehen.

Das war’s! Sie haben Flask erfolgreich installiert und Ihre erste Flask-Anwendung erstellt. Von hier aus können Sie beginnen, Ihre Anwendung zu erweitern und weitere Funktionen hinzuzufügen.

Flask Website

Mein erster Webservice um eine MSSQL Tabelle auzulesen

Um einen Webdienst in Flask zu erstellen, der eine Tabelle in einem MSSQL Server bereitstellt, müssen Sie zunächst sicherstellen, dass Sie den pymssql-Treiber installiert haben. Dieser Treiber ermöglicht es Flask, auf MSSQL-Datenbanken zuzugreifen.

Hier sind die Schritte, um einen einfachen Webdienst in Flask zu erstellen, der eine Tabelle in einem MSSQL Server bereitstellt:

  1. Installieren Sie zunächst den pymssql-Treiber, indem Sie den folgenden Befehl in der Eingabeaufforderung oder im Terminal eingeben:
pip install pymssql
  1. Öffnen Sie Ihren bevorzugten Texteditor und erstellen Sie eine neue Python-Datei. Importieren Sie die erforderlichen Flask- und pymssql-Module:
from flask import Flask, jsonify
import pymssql
  1. Erstellen Sie eine neue Flask-App und konfigurieren Sie die Verbindungsdaten für den MSSQL Server:
app = Flask(__name__)

# Konfiguration für den MSSQL Server
app.config['MSSQL_SERVER'] = 'your_server_name'
app.config['MSSQL_DATABASE'] = 'your_database_name'
app.config['MSSQL_USERNAME'] = 'your_username'
app.config['MSSQL_PASSWORD'] = 'your_password'

Stellen Sie sicher, dass Sie Ihre eigenen Werte für MSSQL_SERVER, MSSQL_DATABASE, MSSQL_USERNAME und MSSQL_PASSWORD angeben.

  1. Erstellen Sie eine neue Flask-Route, die eine Abfrage an den MSSQL Server sendet und die Ergebnisse in JSON-Format zurückgibt:
@app.route('/table')
def get_table_data():
    # Verbindung zum MSSQL Server herstellen
    conn = pymssql.connect(server=app.config['MSSQL_SERVER'], 
                           database=app.config['MSSQL_DATABASE'], 
                           username=app.config['MSSQL_USERNAME'], 
                           password=app.config['MSSQL_PASSWORD'])
    
    # Cursor erstellen und Abfrage ausführen
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM your_table_name')
    
    # Ergebnisse in ein JSON-Objekt konvertieren
    data = []
    for row in cursor.fetchall():
        data.append({
            'column1': row[0],
            'column2': row[1],
            'column3': row[2]
            # usw.
        })
    
    # Verbindung schließen und Ergebnisse zurückgeben
    conn.close()
    return jsonify(data)

Stellen Sie sicher, dass Sie your_table_name durch den Namen der Tabelle ersetzen, auf die Sie zugreifen möchten, und die Spaltennamen in der Schleife entsprechend ändern.

  1. Starten Sie die Flask-App, indem Sie den folgenden Code am Ende Ihrer Datei hinzufügen:
if __name__ == '__main__':
    app.run()
  1. Starten Sie die Anwendung, indem Sie die Datei ausführen:
python your_file_name.py
  1. Öffnen Sie einen Webbrowser und navigieren Sie zu http://localhost:5000/table. Sie sollten die Ergebnisse der Abfrage in JSON-Format sehen.

Das war’s! Sie haben erfolgreich einen Webdienst in Flask erstellt, der eine Tabelle in einem MSSQL Server bereitst

Beispiel eines Microservices für eine Berechnung

Gerne zeige ich Ihnen, wie Sie einen einfachen Microservice in Flask erstellen können. In diesem Beispiel erstellen wir einen Microservice, der eine einfache Berechnung durchführt.

  1. Installieren Sie Flask, falls es noch nicht installiert ist. Sie können dies über die Eingabeaufforderung oder das Terminal mit dem Befehl pip install Flask tun.

  2. Öffnen Sie Ihren bevorzugten Texteditor und erstellen Sie eine neue Python-Datei. Importieren Sie die Flask-Module:

from flask import Flask, jsonify, request
  1. Erstellen Sie eine neue Flask-App:
app = Flask(__name__)
  1. Erstellen Sie eine neue Flask-Route, die eine POST-Anforderung akzeptiert und eine Berechnung durchführt:
@app.route('/calculate', methods=['POST'])
def calculate():
    # Die POST-Daten erhalten und die Berechnung durchführen
    data = request.get_json()
    result = data['a'] + data['b']
    
    # Das Ergebnis in ein JSON-Objekt konvertieren und zurückgeben
    response = {'result': result}
    return jsonify(response)
  1. Starten Sie die Flask-App, indem Sie den folgenden Code am Ende Ihrer Datei hinzufügen:
if __name__ == '__main__':
    app.run()
  1. Starten Sie die Anwendung, indem Sie die Datei ausführen:
python your_file_name.py
  1. Öffnen Sie einen API-Client wie Postman oder cURL und senden Sie eine POST-Anforderung an http://localhost:5000/calculate mit den folgenden Daten im JSON-Format:
{
    "a": 2,
    "b": 3
}
  1. Die Antwort sollte das Ergebnis der Berechnung als JSON-Objekt enthalten:
{
    "result": 5
}

Das war’s! Sie haben erfolgreich einen Microservice in Flask erstellt, der eine einfache Berechnung durchführt. Natürlich können Sie die Funktionalität des Microservices erweitern und komplexere Aufgaben ausführen lassen.

Unternehmensweiter Seriennummerngenerator mit SQLite

Hier ist ein Beispielcode für einen Flask-Webservice, der eine fortlaufende Seriennummer generiert und SQLITE als Datenbank verwendet:

from flask import Flask
import sqlite3

app = Flask(__name__)
DATABASE = 'serial_num.db'

def get_db():
    db = sqlite3.connect(DATABASE)
    db.row_factory = sqlite3.Row
    return db

def init_db():
    with app.app_context():
        db = get_db()
        db.execute('CREATE TABLE IF NOT EXISTS serial_num (id INTEGER PRIMARY KEY AUTOINCREMENT, num INTEGER)')
        db.commit()

@app.route('/generate_serial')
def generate_serial():
    db = get_db()
    cursor = db.cursor()
    cursor.execute('INSERT INTO serial_num (num) VALUES (NULL)')
    db.commit()
    cursor.execute('SELECT MAX(num) FROM serial_num')
    serial_num = cursor.fetchone()[0]
    cursor.close()
    return str(serial_num)

if __name__ == '__main__':
    init_db()
    app.run()

In diesem Beispiel importieren wir Flask und sqlite3, um auf eine SQLITE-Datenbank zuzugreifen. Wir definieren dann eine Funktion get_db(), die eine Verbindung zur Datenbank herstellt, und eine Funktion init_db(), die die Datenbanktabelle serial_num erstellt, wenn sie nicht vorhanden ist. Wir definieren auch eine Route, die auf die URL „/generate_serial“ antwortet. Wenn diese Route aufgerufen wird, fügt sie eine neue Zeile mit einer NULL-Nummer in die Tabelle serial_num ein, ruft die höchste Nummer aus der Tabelle ab und gibt sie als Text zurück.

Um diesen Webservice auszuführen, speichern Sie den obigen Code in einer Datei namens serial_service.py. Installieren Sie Flask, indem Sie das Kommando pip install flask in der Eingabeaufforderung ausführen. Starten Sie den Webservice, indem Sie python serial_service.py in der Eingabeaufforderung ausführen. Wenn alles gut läuft, sollte der Webservice auf http://127.0.0.1:5000/ erreichbar sein. Rufen Sie den Endpunkt „/generate_serial“ auf, indem Sie http://127.0.0.1:5000/generate_serial in Ihrem Webbrowser eingeben oder eine HTTP-Anfrage senden. Der Webservice sollte eine fortlaufende Seriennummer zurückgeben, die bei jedem Aufruf um eins erhöht wird und in der SQLITE-Datenbank gespeichert wird.