Entweder ist Ihre Aufgabe klein, oder Sie können sie in kleinere Aufgaben aufteilen. Und eine kleine Aufgabe passt perfekt zu einem Microservice.

Softwaredesign ist eine wesentliche Phase in der Softwareentwicklung. Der Designansatz kann sich auf das gesamte Projekt und den Umgang mit unterschiedlichen Anforderungen auswirken.

Entwickler haben oft eine monolithische Architektur verwendet und alle Softwarekomponenten in einem einzigen Modul gebündelt. Dieser Ansatz kann sich jedoch insbesondere bei größeren Anwendungen als ineffizient erweisen.

Microservices zielen darauf ab, diese Einschränkungen zu beseitigen. Ein Microservice ist eine kleine, modulare Anwendung, die bestimmte Funktionen ausführt. Im Gegensatz zu monolithischen Anwendungen ermöglichen Microservices eine unabhängige Bereitstellung und Skalierung. Dadurch sind sie flexibler und einfacher zu warten.

Die Microservice-Architektur

Die Microservice-Architektur ist ein Software-Design-Ansatz, der eine große Anwendung in unabhängige Dienste aufteilt, wobei jeder Dienst auf eine bestimmte Geschäftsanforderung zugeschnitten ist.

instagram viewer

Diese Dienste laufen auf dedizierten Ressourcen, einschließlich separater Datenbankinstanzen und Rechenleistung. Im Gegensatz zu monolithischen Systemen sind Microservice-Anwendungen lose gekoppelt, was eine größere Flexibilität ermöglicht.

In einem verteilten System stellen Serverknoten Mikroservice-Anwendungen separat bereit und führen sie aus Prozesse – Kommunikation untereinander über Kommunikationsprotokolle wie HTTP oder über Message Broker wie RabbitMQ.

Im Wesentlichen ermöglicht dieser Architekturansatz den Diensten, ihre Unabhängigkeit voneinander zu bewahren und gleichzeitig effektiv innerhalb des Softwaresystems zu arbeiten.

In diesem Tutorial führen wir Sie durch die Implementierung eines einfachen Benutzer-Microservices, der Benutzerdaten mithilfe von Flask und PostgreSQL verwaltet

Richten Sie eine PostgreSQL-Datenbank ein

Installieren Sie zunächst PostgreSQL. Wenn Sie PostgreSQL nicht installiert haben, können Sie es herausfinden So installieren Sie PostgreSQL unter Windows oder So installieren Sie PostgreSQL unter macOS.

Alternativ können Sie a konfigurieren Remote-PostgreSQL-Datenbank Beispiel.

In dieser Anleitung wird die kostenlose Stufe von Render zum Einrichten einer PostgreSQL-Datenbank verwendet. Befolgen Sie diese Schritte, um eine PostgreSQL-Datenbankinstanz auf Render hochzufahren:

  1. Geh 'rüber zu Renders Website, eröffnen Sie ein Konto und melden Sie sich bei Ihrem an Armaturenbrett Buchseite.
  2. Wählen Sie auf Ihrer Dashboard-Seite aus der Liste der angezeigten Dienste den PostgreSQL-Dienst aus.
  3. Geben Sie auf der Seite mit den Datenbankeinstellungen die erforderlichen Details ein und stellen Sie sicher, dass Sie Folgendes auswählen Kostenlose Stufe, und schließlich klicken Datenbank erstellen.

Den Code dieses Projekts finden Sie hier GitHub-Repository.

Erstellen Sie einen Flask-Microservice

  1. Erstellen Sie in Ihrem Terminal ein neues Verzeichnis und wechseln Sie dorthin:
    mkdir flask-microservice
    CD-Flask-Microservice
  2. Als nächstes installieren virtuelle Umgebung, um eine isolierte virtuelle Entwicklungsumgebung zu erstellen.
    pip installiere virtualenv
  3. Erstellen Sie eine virtuelle Umgebung in Ihrem Projekt:
    virtualenv venv
  4. Aktivieren Sie abschließend die virtuelle Umgebung.
    # Windows: 
    .\venv\Scripts\activate
    # Unix oder MacOS: 
    Quelle venv/bin/activate

Installieren Sie die erforderlichen Pakete

  1. Erstelle eine neue Anforderungen.txt Datei im Stammverzeichnis und fügen Sie diese Pakete hinzu:
    Flasche
    psycopg2-binär
    SQLalchemie
  2. Als nächstes installieren Sie die Pakete.
    pip install -r Anforderungen.txt

Erstellen Sie einen Flask-Server

Erstellen Sie im Stammverzeichnis eine neue Datei: service.pyund den folgenden Code:

  1. Führen Sie die folgenden Importe durch:
    aus Flasche importieren Flasche, Anfrage, jsonify
    aus SQLalchemie importieren create_engine, Spalte, Ganzzahl, String
    aus sqlalchemy.orm importieren Sitzungsmacher
    aus sqlalchemy.ext.declarative importieren declarative_base
    importieren psycopg2
  2. Erstellen Sie die Flask-Instanz und konfigurieren Sie die Datenbankverbindung.
    app = Flasche (__name__)
    engine = create_engine(„postgresql+psycopg2://flask_service_fe0v_user: 4785MhjfkdjfhjfjyUx67O2Nuzjchb2MQIP@dpg-chffjfjdkgfk54d6mb7860-a.oregon-postgres.render.com/flask_service_fe0v“)
    Kopiere das externe Datenbank-URL auf der Seite mit den Datenbankeinstellungen von Render. Wir werden das verwenden SQLAlchemy create_engine Methode und Psycopg2 um die Datenbankverbindung zu konfigurieren. Stellen Sie sicher, dass Sie die Datenbank-URL im obigen Code aktualisieren und durch die URL Ihrer eigenen PostgreSQL-Instanz ersetzen, die dem oben angegebenen Format entspricht. Wenn das URL-Format falsch ist, gibt der Code einen Fehler aus.
  3. Erstellen Sie ein SQLAlchemy-Modell für die Datenbank.
    Base = declarative_base()
    KlasseBenutzer(Base):
     __tablename__ = 'Benutzer'
     id = Spalte (Ganzzahl, primärer_schlüssel=WAHR)
     name = Spalte (String(50))
    Base.metadata.create_all (Engine)
    drucken(„Tabelle ‚Benutzer‘ erfolgreich erstellt.“)
    Session = Sessionmaker (Engine)
    Der Code definiert ein Datenmodell für die Benutzertabelle. Nach der Definition des Modells wird die Tabelle mithilfe von erstellt SQLAlchemy create_all Methode, die die Datenbank übernimmt Verbindungs-Engine-Objekt als Parameter. Schließlich wird eine Instanz von erstellt Sitzungsmacher Verwenden desselben Engine-Objekts, um Interaktionen mit der Datenbank zu ermöglichen.
  4. Definieren Sie abschließend die API-Routen für den Microservice.
    @app.route("/api/user", method=["POST"])
    defcreate_user():
     data = request.get_json()
     Name = Daten["Name"]
    versuchen:
     Sitzung = Sitzung()
     new_user = Benutzer (Name=Name)
     session.add (new_user)
     session.commit()
    zurückkehren {"Ausweis": new_user.id, "Name": Neuer Benutzername, "Nachricht": f"Benutzer {Name} erstellt.“}, 201
    außer Ausnahme als e:
     drucken(f"Der Fehler '{e}' geschah.")
    zurückkehren {"Fehler": „Beim Erstellen des Benutzers ist ein Fehler aufgetreten.“}, 500
    @app.route("/api/user", method=["GET"])
    defget_all_users():
    versuchen:
     Sitzung = Sitzung()
     Benutzer = session.query (Benutzer).all()
    Wenn Benutzer:
     Ergebnis = []
    für Benutzer In Benutzer:
     result.append({"Ausweis": Benutzer-ID, "Name": Nutzername})
    zurückkehren jsonify (Ergebnis)
    anders:
    zurückkehren jsonify({"Fehler": f „Benutzer nicht gefunden.“}), 404
    außer Ausnahme als e:
     drucken(f"Der Fehler '{e}' geschah.")
    zurückkehren {"Fehler": „Beim Abrufen aller Benutzer ist ein Fehler aufgetreten.“}, 500
    Wenn __name__ == "__hauptsächlich__":
     app.run (debug=WAHR, host="0.0.0.0")

Testen Sie den Microservice

Der obige Code demonstriert einen einfachen Benutzerdaten-Microservice, der Daten zu einer PostgreSQL-Datenbank hinzufügt und daraus abruft. Im Idealfall spiegeln Microservices das wider REST-API-Architektur Da sie einen flexiblen Ansatz zum Aufbau von Webdiensten ermöglicht, passt diese Architektur gut zum Entwurfsmuster von Microservices.

Es ist jedoch wichtig zu beachten, dass Microservices je nach den spezifischen Anforderungen des Systems auch andere Arten von Designansätzen und Kommunikationsprotokollen verwenden können.

Um den Dienst zu testen, starten Sie den Entwicklungsserver und gehen Sie zu Postman, um HTTP-Anfragen an die definierten Endpunkte zu stellen.

flask --app-Dienst ausführen

Stellen Sie in Postman eine POST-Anfrage, um Benutzerdaten hinzuzufügen.

Containerisieren von Microservices mit Docker

Docker bündelt Anwendungen und ihre Abhängigkeiten in Containern. Dieser Ansatz optimiert die Entwicklung, Bereitstellung und Verwaltung von Microservices in einer Produktionsumgebung da jeder Dienst unabhängig arbeiten und über die konfigurierte Kommunikation mit anderen Diensten kommunizieren kann Protokoll.

Bevor Sie beginnen, müssen Sie zunächst Docker installieren, indem Sie die Schritte auf der befolgen Docker-Website. Erstellen Sie dann ein Docker-Image aus einer Docker-Datei, das die notwendigen Anweisungen zum Einrichten der erforderlichen Abhängigkeiten zum Ausführen der Anwendung in einem Container enthält.

  1. Erstellen Sie eine Docker-Datei im Stammverzeichnis Ihres Projektordners und fügen Sie diese Anweisungen hinzu:
    AUS Python:3.9-alpin
    ARBEITSVERZEICHNIS /app
    KOPIEREN Anforderungen.txt ./
    LAUFEN pip install -r Anforderungen.txt
    KOPIEREN. .
    EXPONIEREN5000
    CMD ["Python", „./service.py“]
  2. Führen Sie den folgenden Befehl aus, um das Docker-Image zu erstellen.
     docker build -t flask-microservice .
  3. Führen Sie abschließend den Docker-Container aus.
    docker run -p 5000:5000 flask-microservice

Dadurch wird ein Docker-Container gestartet, auf dem der Flask-Mikrodienst ausgeführt wird, und Port 5000 auf dem Container wird verfügbar gemacht Port 8000 auf dem Host-Computer, sodass Sie über Ihren Webbrowser oder Postman HTTP-Anfragen stellen können URL http://localhost: 5000.

Einführung der Microservice-Architektur

Die Microservices-Architektur ist zu einem beliebten Ansatz für die Entwicklung skalierbarer und robuster Softwareanwendungen geworden. Durch die Aufteilung der Anwendung in kleine, unabhängig einsetzbare Dienste erleichtert die Microservices-Architektur die Wartung und Skalierung des Systems.

Obwohl diese Architektur potenzielle Vorteile bietet, ist sie nicht für alle Anwendungsfälle geeignet. In jedem Fall sollten die spezifischen Geschäftsanforderungen des Projekts in erster Linie den gewählten Designansatz beeinflussen.