{"id":67562,"date":"2023-12-05T13:25:35","date_gmt":"2023-12-05T12:25:35","guid":{"rendered":"https:\/\/kinsta.com\/de\/?p=67562&#038;preview=true&#038;preview_id=67562"},"modified":"2023-12-28T16:23:11","modified_gmt":"2023-12-28T15:23:11","slug":"python-microservices","status":"publish","type":"post","link":"https:\/\/kinsta.com\/de\/blog\/python-microservices\/","title":{"rendered":"Wie man Microservices mit Python erstellt und einsetzt"},"content":{"rendered":"<p>In der modernen Softwareentwicklung haben sich Microservices zu einer zentralen Architektur entwickelt, die Skalierbarkeit, Flexibilit\u00e4t und effizientes Management komplexer Systeme erm\u00f6glicht.<\/p>\n<p>Microservices sind kleine, unabh\u00e4ngige Anwendungen, die bestimmte Aufgaben erf\u00fcllen und eine flexible Bereitstellung und Skalierung erm\u00f6glichen. Dieser modulare Ansatz f\u00fcr das Softwaredesign lockert die Kopplung zwischen den Komponenten und verbessert die Flexibilit\u00e4t und Verwaltbarkeit w\u00e4hrend der Entwicklung.<\/p>\n<p>Der Artikel gibt einen \u00dcberblick \u00fcber <a href=\"https:\/\/kinsta.com\/de\/blog\/microservices-vs-api\/\">Microservices<\/a>, ihre Funktionen und ihre Erstellung mit <a href=\"https:\/\/kinsta.com\/de\/blog\/python-befehle\/\">Python<\/a>. Au\u00dferdem wird gezeigt, wie du deine Microservices mithilfe eines <a href=\"https:\/\/docs.sevalla.com\/applications\/build-options\/dockerfile\">Dockerfiles<\/a> auf Kinsta bereitstellst.<\/p>\n<div><\/div><kinsta-auto-toc heading=\"Table of Contents\" exclude=\"last\" list-style=\"arrow\" selector=\"h2\" count-number=\"-1\"><\/kinsta-auto-toc>\n<h2>Was sind Microservices?<\/h2>\n<p>Microservices sind unabh\u00e4ngige, autonome Dienste innerhalb einer Anwendung, die jeweils spezifische Gesch\u00e4ftsanforderungen erf\u00fcllen. Sie kommunizieren \u00fcber leichtgewichtige <a href=\"https:\/\/kinsta.com\/de\/blog\/api-endpunkt\/\">APIs<\/a> oder Message-Broker und bilden so ein umfassendes System.<\/p>\n<p>Im Gegensatz zu <a href=\"https:\/\/kinsta.com\/de\/blog\/function-as-a-service\/#how-does-faas-work\">monolithischen<\/a> Systemen, die sich ganz nach Bedarf skalieren lassen, erm\u00f6glichen Microservices die Skalierung einzelner Komponenten mit hohem Verkehrsaufkommen. Diese Architektur erleichtert das Fehlermanagement und die Aktualisierung von Funktionen und wirkt den monolithischen Einschr\u00e4nkungen entgegen.<\/p>\n<p>Der Einsatz von Microservices bietet mehrere Vorteile, wie z. B.:<\/p>\n<ul>\n<li><strong>Flexibilit\u00e4t und Skalierbarkeit<\/strong> &#8211; Durch die Entkopplung einzelner Dienste kannst du die Anzahl der Knoten erh\u00f6hen, auf denen eine Instanz eines bestimmten Dienstes mit hohem Datenverkehr l\u00e4uft.<\/li>\n<li><strong>Modularit\u00e4t des Codes<\/strong> &#8211; Jeder Dienst kann einen eigenen Technologie-Stack verwenden, sodass du die besten Entwicklungswerkzeuge f\u00fcr jeden Dienst ausw\u00e4hlen kannst.<\/li>\n<\/ul>\n<p>Microservice-Architekturen sind jedoch mit einigen Herausforderungen verbunden:<\/p>\n<ul>\n<li><strong>\u00dcberwachung mehrerer Dienste<\/strong> &#8211; Die \u00dcberwachung der einzelnen Dienste in einem System wird schwierig, wenn Instanzen eines bestimmten Dienstes \u00fcber mehrere Knotenpunkte verteilt sind. Diese Schwierigkeit wird besonders bei Netzwerkausf\u00e4llen oder anderen Systemproblemen deutlich.<\/li>\n<li><strong>Kosten<\/strong> &#8211; Die Entwicklung von Microservice-Anwendungen kann aufgrund der Kosten, die mit der Verwaltung mehrerer Dienste verbunden sind, deutlich teurer sein als der Aufbau monolithischer Systeme. Jeder Dienst ben\u00f6tigt eine eigene Infrastruktur und eigene Ressourcen, was teuer werden kann &#8211; vor allem, wenn das System vergr\u00f6\u00dfert wird.<\/li>\n<\/ul>\n<h2>Wie man einen Microservice mit Python entwickelt<\/h2>\n<p>Jetzt, wo du die Vorteile einer Microservice-Architektur kennst, ist es an der Zeit, eine solche mit Python zu entwickeln.<\/p>\n<p>In diesem Beispiel nimmst du an, dass du eine <a href=\"https:\/\/kinsta.com\/ecommerce\/\">E-Commerce-Webanwendung<\/a> erstellen willst. Die Website hat mehrere Komponenten, darunter den Produktkatalog, eine Liste der Bestellungen, ein Zahlungssystem und Protokolle, die du jeweils als unabh\u00e4ngigen Dienst implementieren musst. Au\u00dferdem musst du eine Kommunikationsmethode von Dienst zu Dienst einrichten, um Daten zwischen diesen Diensten effizient zu \u00fcbertragen, wie z. B. <a href=\"https:\/\/kinsta.com\/de\/blog\/http-statuscodes\/\">HTTP<\/a>.<\/p>\n<p>Lass uns einen Microservice mit Python erstellen, um einen Produktkatalog zu verwalten. Der Microservice wird Produktdaten aus einer bestimmten Quelle abrufen und die Daten im JSON-Format zur\u00fcckgeben.<\/p>\n<h3>Voraussetzungen<\/h3>\n<p>Um diesem Tutorial zu folgen, musst du Folgendes haben<\/p>\n<ul>\n<li>Vertrautheit mit <a href=\"https:\/\/flask.palletsprojects.com\/en\/2.3.x\/\" target=\"_blank\" rel=\"noopener noreferrer\">Flask<\/a><\/li>\n<li><a href=\"https:\/\/kinsta.com\/de\/blog\/python-installieren\/\">Python<\/a>, <a href=\"https:\/\/www.postman.com\/\" target=\"_blank\" rel=\"noopener noreferrer\">Postman Client<\/a> und <a href=\"https:\/\/www.docker.com\/products\/docker-desktop\/\" target=\"_blank\" rel=\"noopener noreferrer\">Docker Desktop<\/a> auf deinem Rechner installiert hast<\/li>\n<\/ul>\n<h3>1. Erstelle dein Projekt<\/h3>\n<ol start=\"1\">\n<li>Um loszulegen, erstelle einen Ordner f\u00fcr dein Projekt mit dem Namen <strong>flask-microservice<\/strong> und das aktuelle Verzeichnis im Projektverzeichnis.<\/li>\n<li>F\u00fchre als N\u00e4chstes <code>python3 --version<\/code> aus, um sicherzustellen, dass Python korrekt auf deinem Computer installiert ist.<\/li>\n<li>Installiere <code>virtualenv<\/code>, um eine isolierte Entwicklungsumgebung f\u00fcr den Flask-Microservice zu schaffen, indem du den folgenden Befehl ausf\u00fchrst:\n<pre><code class=\"language-bash\">pip3 install virtualenv<\/code><\/pre>\n<\/li>\n<li>Erstelle eine virtuelle Umgebung, indem du den folgenden Befehl ausf\u00fchrst:\n<pre><code class=\"language-bash\">virtualenv venv<\/code><\/pre>\n<\/li>\n<li>Schlie\u00dflich aktivierst du die virtuelle Umgebung mit einem der folgenden Befehle, je nach Betriebssystem deines Computers:\n<pre><code class=\"language-bash\"># Windows: \n.\\venv\\Scripts\\activate\n# Unix or macOS:\nsource venv\/bin\/activate<\/code><\/pre>\n<\/li>\n<\/ol>\n<h3>2. Einen Flask-Server einrichten<\/h3>\n<p>Erstelle im Stammverzeichnis eine Datei <strong>requirements.txt<\/strong> und f\u00fcge diese Abh\u00e4ngigkeiten hinzu.<\/p>\n<pre><code class=\"language-bash\">flask\nrequests<\/code><\/pre>\n<p>F\u00fchre die <code><a href=\"https:\/\/kinsta.com\/de\/blog\/python-frameworks\/#the-python-package-manager-pip\">pip3<\/a><code> command on your terminal to install the dependencies.<\/code><\/code><\/p>\n<pre><code class=\"language-bash\">pip install -r requirements.txt<\/code><\/pre>\n<p>Als n\u00e4chstes erstellst du einen neuen Ordner im Stammverzeichnis und nennst ihn <strong>services<\/strong>. In diesem Ordner erstellst du eine neue Datei, <strong>products.py<\/strong>, und f\u00fcgst den unten stehenden Code hinzu, um einen Flask-Server einzurichten.<\/p>\n<pre><code class=\"language-python\">import requests\nimport os\nfrom flask import Flask, jsonify\napp = Flask(__name__)\nport = int(os.environ.get('PORT', 5000))\n\n@app.route(\"\/\")\ndef home():\n    return \"Hello, this is a Flask Microservice\"\nif __name__ == \"__main__\":\n    app.run(debug=True, host=\"0.0.0.0\", port=port)<\/code><\/pre>\n<p>Mit dem obigen Code wird ein einfacher Flask-Server eingerichtet. Er initialisiert eine Flask-Anwendung, definiert eine einzelne Route f\u00fcr die Stamm-URL (<code>\"\/\"<\/code>) und zeigt beim Aufruf die Meldung <code>\"Hello, this is a Flask Microservice\"<\/code> an. Der Server l\u00e4uft auf einem bestimmten Port, der \u00fcber eine Umgebungsvariable ermittelt wird, oder standardm\u00e4\u00dfig auf dem Port <code>5000<\/code> und startet im Debugging-Modus, damit er eingehende Anfragen bearbeiten kann.<\/p>\n<h3>3. Definiere die API-Endpunkte<\/h3>\n<p>Nachdem der Server konfiguriert ist, erstellst du einen API-Endpunkt f\u00fcr einen Microservice, der Produktdaten von einer <a href=\"https:\/\/dummyjson.com\" target=\"_blank\" rel=\"noopener noreferrer\">\u00f6ffentlich verf\u00fcgbaren API<\/a> abruft. F\u00fcge diesen Code in die Datei <strong>products.py<\/strong> ein:<\/p>\n<pre><code class=\"language-python\">BASE_URL = \"https:\/\/dummyjson.com\"\n@app.route('\/products', methods=['GET'])\ndef get_products():\n    response = requests.get(f\"{BASE_URL}\/products\")\n    if response.status_code != 200:\n        return jsonify({'error': response.json()['message']}), response.status_code\n    products = []\n    for product in response.json()['products']:\n        product_data = {\n            'id': product['id'],\n            'title': product['title'],\n            'brand': product['brand'],\n            'price': product['price'],\n            'description': product['description']\n        }\n        products.append(product_data)\n    return jsonify({'data': products}), 200 if products else 204<\/code><\/pre>\n<p>Der obige Code erstellt einen <code>\/products<\/code> Endpunkt im Flask-Server. Wenn er \u00fcber eine GET-Anfrage aufgerufen wird, holt er die Produktdaten von einer Dummy-API ab. Bei Erfolg verarbeitet er die abgerufenen Daten, extrahiert Produktdetails und gibt die Informationen im JSON-Format zur\u00fcck. Bei Fehlern oder wenn keine Daten verf\u00fcgbar sind, antwortet sie mit einer entsprechenden Fehlermeldung und einem Statuscode.<\/p>\n<h3>4. Teste den Microservice<\/h3>\n<p>Jetzt hast du erfolgreich einen einfachen Microservice eingerichtet. Um den Dienst zu starten, fahre den Entwicklungsserver hoch, der unter <code>http:\/\/localhost:5000<\/code> gestartet wird.<\/p>\n<pre><code class=\"language-bash\">flask --app services\/products run<\/code><\/pre>\n<p>Dann kannst du mit dem Postman-Client eine <code>GET<\/code> -Anfrage an den Endpunkt <code>\/products<\/code> stellen. Du solltest eine \u00e4hnliche Antwort wie auf dem Screenshot unten sehen.<\/p>\n<figure style=\"width: 1001px\" class=\"wp-caption alignnone\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/11\/testing-endpoint-locally.jpg\" alt=\"Erfolgreiche GET-Anfrage an den Endpunkt des Dummy-API-Produkts in Postman\" width=\"1001\" height=\"471\"><figcaption class=\"wp-caption-text\">Testen der HTTP API <code>GET<\/code> Anfrage in Postman<\/figcaption><\/figure>\n<h2>Wie man Authentifizierung und Autorisierung in einem Python Microservice implementiert<\/h2>\n<p>Wenn du Microservices entwickelst, ist es wichtig, robuste Sicherheitsma\u00dfnahmen wie Authentifizierung und Autorisierung zu implementieren. Die Absicherung deines Microservices stellt sicher, dass nur autorisierte Nutzer\/innen auf den Dienst zugreifen und ihn nutzen k\u00f6nnen, um sensible Daten zu sch\u00fctzen und b\u00f6sartige Angriffe zu verhindern.<\/p>\n<p>Eine wirksame Methode zur Implementierung sicherer Authentifizierung und Autorisierung in Microservices sind JSON Web Tokens (JWTs).<\/p>\n<p>JWT ist ein weit verbreiteter offener Standard, der eine sichere und effiziente Methode zur \u00dcbermittlung von Authentifizierungsinformationen zwischen Clients und Servern bietet. Es handelt sich dabei um kompakte, verschl\u00fcsselte und digital signierte Token, die du mit HTTP-Anfragen weitergibst. Wenn du jeder Anfrage ein JWT beif\u00fcgst, kann der Server schnell die Identit\u00e4t und die Berechtigungen eines Nutzers \u00fcberpr\u00fcfen.<\/p>\n<p>Um die JWT-Authentifizierung in einem Microservice zu implementieren, musst du Folgendes tun:<\/p>\n<ol start=\"1\">\n<li>F\u00fcge das Python-Paket <code>pyjwt<\/code> zu deiner <strong>requirements.txt-Datei<\/strong> hinzu und installiere die Abh\u00e4ngigkeiten mit <code>pip install -r requirements.txt<\/code> neu.<\/li>\n<li>Da der Dienst keine eigene Datenbank hat, erstelle eine <strong>users.json<\/strong> Datei im Hauptverzeichnis deines Projekts, um eine Liste der autorisierten Benutzer zu speichern. F\u00fcge den folgenden Code in die Datei ein:\n<pre><code class=\"language-json\">[\n    {   \n        \"id\": 1,\n        \"username\": \"admin\",\n        \"password\": \"admin\"\n    \n    }\n]<\/code><\/pre>\n<p><aside role=\"note\" class=\"wp-block-kinsta-notice is-style-info\">\n            <h3>Info<\/h3>\n        <p>Du kannst deine bevorzugte Datenbank (<a href=\"https:\/\/kinsta.com\/de\/blog\/was-ist-postgresql\/\">PostgreSQL<\/a>, <a href=\"https:\/\/kinsta.com\/de\/blog\/mariadb-python\/\">MariaDB<\/a>, <a href=\"https:\/\/kinsta.com\/de\/blog\/redis-docker\/\">Redis<\/a> und <a href=\"https:\/\/kinsta.com\/de\/thema\/mysql-datenbank\/\">MySQL<\/a>) f\u00fcr deine Microservices ganz einfach mit unserem <a href=\"https:\/\/sevalla.com\/database-hosting\/\">Datenbank-Hosting-Service<\/a> einrichten.<\/p>\n<\/aside>\n<\/li>\n<li>Ersetze dann in deiner <strong>services\/products.py-Datei<\/strong> die import-Anweisungen durch die folgenden:\n<pre><code class=\"language-python\">import requests \nfrom flask import Flask, jsonify, request, make_response\nimport jwt\nfrom functools import wraps\nimport json\nimport os\nfrom jwt.exceptions import DecodeError<\/code><\/pre>\n<p>Du importierst diese Module, um HTTP-Anfragen zu bearbeiten, eine Flask-Anwendung zu erstellen, JSON-Daten zu verwalten, eine JWT-basierte Authentifizierung zu implementieren und Ausnahmen zu behandeln, was eine Vielzahl von Funktionen innerhalb des <a href=\"https:\/\/kinsta.com\/de\/blog\/flask-vs-django\/\">Flask-Servers<\/a> erm\u00f6glicht.<\/li>\n<li>F\u00fcge den folgenden Code nach der Erstellung der Flask-Anwendungs-Instanz ein, um einen geheimen Schl\u00fcssel zu erzeugen, der zum Signieren der JWT-Tokens verwendet wird.\n<pre><code class=\"language-python\">app.config['SECRET_KEY'] = os.urandom(24)<\/code><\/pre>\n<\/li>\n<li>Um JWTs zu verifizieren, erstellst du eine Decorator-Funktion und f\u00fcgst den folgenden Code oberhalb der API-Routen in deinem Flask-Servercode ein. Diese Dekorfunktion authentifiziert und validiert die Nutzer, bevor sie auf gesch\u00fctzte Routen zugreifen.\n<pre><code class=\"language-python\">def token_required(f):\n    @wraps(f)\n    def decorated(*args, **kwargs):\n        token = request.cookies.get('token')\n        if not token:\n            return jsonify({'error': 'Authorization token is missing'}), 401\n        try:\n            data = jwt.decode(token, app.config['SECRET_KEY'], algorithms=[\"HS256\"])\n            current_user_id = data['user_id']\n        except DecodeError:\n            return jsonify({'error': 'Authorization token is invalid'}), 401\n        return f(current_user_id, *args, **kwargs)\n    return decorated<\/code><\/pre>\n<p>Diese Decorator-Funktion pr\u00fcft eingehende HTTP-Anfragen auf ein JWT-Autorisierungs-Token, das in den Anfrage-Headern oder Cookies enthalten sein sollte. Wenn das Token fehlt oder ung\u00fcltig ist, sendet der Dekorator eine <code>unauthorized status code<\/code> Nachricht als Antwort.<\/p>\n<p>Ist hingegen ein g\u00fcltiges Token vorhanden, extrahiert der Dekorator nach der Entschl\u00fcsselung die Benutzer-ID. Dieser Prozess sch\u00fctzt die gesch\u00fctzten API-Endpunkte, indem er nur autorisierten Nutzern den Zugang gew\u00e4hrt.<\/li>\n<li>Definiere einen API-Endpunkt f\u00fcr die Benutzerauthentifizierung mithilfe des folgenden Codes.\n<pre><code class=\"language-python\">with open('users.json', 'r') as f:\n    users = json.load(f)\n@app.route('\/auth', methods=['POST'])\ndef authenticate_user():\n    if request.headers['Content-Type'] != 'application\/json':\n        return jsonify({'error': 'Unsupported Media Type'}), 415\n    username = request.json.get('username')\n    password = request.json.get('password')\n    for user in users:\n        if user['username'] == username and user['password'] == password:\n            token = jwt.encode({'user_id': user['id']}, app.config['SECRET_KEY'],algorithm=\"HS256\")\n            response = make_response(jsonify({'message': 'Authentication successful'}))\n            response.set_cookie('token', token)\n            return response, 200\n    return jsonify({'error': 'Invalid username or password'}), 401<\/code><\/pre>\n<p>Um Nutzer zu authentifizieren und zu autorisieren, \u00fcberpr\u00fcft der <code>\/auth<\/code> API-Endpunkt die Anmeldeinformationen im JSON-Payload der <code>POST<\/code> Anfrage mit der Liste der zugelassenen Nutzer. Wenn die Anmeldedaten g\u00fcltig sind, wird ein JWT-Token mit der ID des Nutzers und dem geheimen Schl\u00fcssel der Anwendung erstellt und als Cookie in der Antwort gespeichert. Mit diesem Token k\u00f6nnen die Nutzer nun weitere API-Anfragen stellen.<\/p>\n<p>Nachdem du den Endpunkt <code>\/auth<\/code> erstellt hast, schickst du mit Postman eine HTTP-Anfrage <code>POST<\/code> an <code>http:\/\/localhost:5000\/auth<\/code>. In den Request Body f\u00fcgst du die Anmeldedaten des von dir erstellten Pseudo-Admin-Benutzers ein.<\/p>\n<figure style=\"width: 1001px\" class=\"wp-caption alignnone\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/11\/authentication-request.png\" alt=\"Die Postman-Anfrage zeigt den Request Body\" width=\"1001\" height=\"471\"><figcaption class=\"wp-caption-text\">Die Postman-Anfrage zeigt den Request Body<\/figcaption><\/figure>\n<p>Wenn die Anfrage erfolgreich ist, generiert die API ein JWT-Token, legt es in den Cookies von Postman ab und sendet eine authentifizierte Erfolgsmeldung.<\/li>\n<li>Aktualisiere abschlie\u00dfend den <code>GET<\/code> API-Endpunkt, um das JWT-Token mit dem folgenden Code zu pr\u00fcfen und zu verifizieren:\n<pre><code class=\"language-python\">@app.route('\/products', methods=['GET'])\n@token_required\ndef get_products(current_user_id):\n    headers = {'Authorization': f'Bearer {request.cookies.get(\"token\")}'}    \n    response = requests.get(f\"{BASE_URL}\/products\", headers=headers)\n    if response.status_code != 200:\n        return jsonify({'error': response.json()['message']}), response.status_code\n    products = []\n    for product in response.json()['products']:\n        product_data = {\n            'id': product['id'],\n            'title': product['title'],\n            'brand': product['brand'],\n            'price': product['price'],\n            'description': product['description']\n        }\n        products.append(product_data)\n    return jsonify({'data': products}), 200 if products else 204<\/code><\/pre>\n<\/li>\n<\/ol>\n<h2>Wie man Python Microservices mit Docker containerisiert<\/h2>\n<p><a href=\"https:\/\/kinsta.com\/de\/blog\/was-ist-docker\/\">Docker<\/a> ist eine Plattform, die Anwendungen und ihre Abh\u00e4ngigkeiten in einer isolierten Entwicklungsumgebung verpackt. Das Verpacken von Microservices in Containern vereinfacht ihre Bereitstellung und Verwaltung auf Servern, da jeder Dienst unabh\u00e4ngig in seinem Container l\u00e4uft und ausgef\u00fchrt wird.<\/p>\n<p>Um einen Microservice in einen Container zu packen, musst du ein Docker-Image aus einer <a href=\"https:\/\/docs.sevalla.com\/applications\/build-options\/dockerfile\">Dockerdatei<\/a> erstellen, in der die Abh\u00e4ngigkeiten angegeben sind, die f\u00fcr die Ausf\u00fchrung der Anwendung in einem Container erforderlich sind. Erstelle ein <strong>Dockerfile<\/strong> im Stammverzeichnis deines Projekts und f\u00fcge diese Anweisungen hinzu:<\/p>\n<pre><code class=\"language-bash\">FROM python:3.9-alpine\nWORKDIR \/app\nCOPY requirements.txt .\/\nRUN pip install -r requirements.txt\nCOPY . .\nEXPOSE 5000\nCMD [\"python\", \".\/services\/products.py\"]<\/code><\/pre>\n<p>Bevor du das Image erstellst, solltest du dir diese Befehle ansehen:<\/p>\n<ul>\n<li><code>FROM<\/code> &#8211; Weist Docker an, welches Basis-Image verwendet werden soll. Ein Basis-Image ist eine vorgefertigte Instanz, die die Software und Abh\u00e4ngigkeiten enth\u00e4lt, um die Flask-Anwendung in einem Container auszuf\u00fchren.<\/li>\n<li><code>WORKDIR<\/code> &#8211; Legt das angegebene Verzeichnis innerhalb des Containers als Arbeitsverzeichnis fest.<\/li>\n<li><code>COPY requirements.txt .\/<\/code> &#8211; Kopiert die Abh\u00e4ngigkeiten aus der Datei <strong>requirements.txt<\/strong> in die Datei <strong>requirements.txt<\/strong> des Containers.<\/li>\n<li><code>RUN<\/code> &#8211; F\u00fchrt den angegebenen Befehl aus, um die f\u00fcr das Image erforderlichen Abh\u00e4ngigkeiten zu installieren.<\/li>\n<li><code>COPY . .<\/code> &#8211; Kopiert alle Dateien aus dem Stammverzeichnis des Projekts in das Arbeitsverzeichnis des Containers.<\/li>\n<li><code>EXPOSE<\/code> &#8211; Legt den Port fest, an dem der Container auf Anfragen lauschen soll. Docker ver\u00f6ffentlicht den Port jedoch nicht auf dem Host-Rechner.<\/li>\n<li><code>CMD<\/code> &#8211; Legt den Standardbefehl fest, der beim Starten des Containers ausgef\u00fchrt werden soll.<\/li>\n<\/ul>\n<p>Als N\u00e4chstes f\u00fcgst du eine <strong>.dockerignore-Datei <\/strong>in das Stammverzeichnis deines Projekts ein, um die Dateien anzugeben, die das Docker-Image ausschlie\u00dfen soll. Wenn du den Inhalt des Images einschr\u00e4nkst, verringert sich seine endg\u00fcltige Gr\u00f6\u00dfe und die damit verbundene Erstellungszeit.<\/p>\n<pre><code class=\"language-bash\">\/venv\n\/services\/__pycache__\/\n.gitignore<\/code><\/pre>\n<p>F\u00fchre nun den folgenden Befehl aus, um das Docker-Image zu erstellen:<\/p>\n<pre><code class=\"language-bash\">docker build -t flask-microservice .<\/code><\/pre>\n<p>Sobald das Image erstellt ist, kannst du den Microservice mit dem folgenden Befehl in einem Docker-Container ausf\u00fchren:<\/p>\n<pre><code class=\"language-bash\">docker run -p 5000:5000 flask-microservice<\/code><\/pre>\n<p>Mit diesem Befehl wird ein Docker-Container gestartet, in dem der Microservice ausgef\u00fchrt wird, und der Port 5000 des Containers wird f\u00fcr den Port 5000 des Host-Rechners freigegeben, so dass du HTTP-Anfragen von deinem Webbrowser oder Postman \u00fcber die URL <code>http:\/\/localhost:5000<\/code> stellen kannst.<\/p>\n<h2>Python Microservices mit Kinsta bereitstellen<\/h2>\n<p>Kinsta bietet Managed-Hosting-L\u00f6sungen f\u00fcr Webanwendungen und Datenbanken &#8211; du kannst deine Python-Microservices und Backend-APIs nahtlos in einer Produktionsumgebung bereitstellen und verwalten.<\/p>\n<p>Befolge diese Schritte, um deinen Flask-Microservice f\u00fcr die Bereitstellung mit MyKinsta zu konfigurieren:<\/p>\n<ol start=\"1\">\n<li>Erstelle zun\u00e4chst ein neues <strong>Procfile<\/strong> im Stammverzeichnis und f\u00fcge den unten stehenden Code ein. Er gibt den Befehl an, um den Flask-Microservice auf dem Gunicorn WSGI HTTP Server f\u00fcr Python-Anwendungen von Kinsta auszuf\u00fchren.\n<pre><code class=\"language-bash\">web: gunicorn services.wsgi<\/code><\/pre>\n<\/li>\n<li>F\u00fcge in deiner Datei <strong>requirements.txt<\/strong> die Gunicorn-Abh\u00e4ngigkeit hinzu:\n<pre><code class=\"language-bash\">gunicorn==20.1.*<\/code><\/pre>\n<\/li>\n<li>Als n\u00e4chstes erstellst du eine neue Datei <strong>services\/wsgi.py<\/strong> und f\u00fcgst den folgenden Code hinzu.\n<pre><code class=\"language-python\">from services.products import app as application\nif __name__ == \"__main__\":\n                application.run()<\/code><\/pre>\n<\/li>\n<li>Erstelle eine <strong>.gitignore-Datei<\/strong> im Stammverzeichnis des Projekts und f\u00fcge Folgendes hinzu:\n<pre><code class=\"language-bash\">services\/__pycache__\nvenv<\/code><\/pre>\n<\/li>\n<li>Zum Schluss erstellst du ein neues Repository auf GitHub und ver\u00f6ffentlichst deine Projektdateien.<\/li>\n<\/ol>\n<p>Sobald dein Repository fertig ist, befolge diese Schritte, um den Flask-Microservice auf Kinsta bereitzustellen:<\/p>\n<ol start=\"1\">\n<li>Logge dich ein oder erstelle ein Konto, um dein <a href=\"https:\/\/my.kinsta.com\/?lang=de\" target=\"_blank\" rel=\"noopener noreferrer\">MyKinsta-Dashboard<\/a> zu sehen.<\/li>\n<li>Autorisiere Kinsta mit deinem Git-Anbieter (<a href=\"https:\/\/docs.sevalla.com\/applications\/git\/bitbucket#grant-access-to-the-kinsta-bitbucket-application\">Bitbucket<\/a>, <a href=\"https:\/\/docs.sevalla.com\/applications\/git\/github#authenticate-and-authorize\">GitHub<\/a> oder <a href=\"https:\/\/docs.sevalla.com\/applications\/git\/gitlab#authorize-the-kinsta-gitlab-application\">GitLab<\/a>).<\/li>\n<li>Klicke in der linken Seitenleiste auf <strong>Anwendungen<\/strong> und dann auf <strong>Anwendung hinzuf\u00fcgen<\/strong>.<\/li>\n<li>Klicke auf dem Dashboard auf <strong>Dienst hinzuf\u00fcgen<\/strong> und w\u00e4hle <strong>Anwendung<\/strong>.<\/li>\n<li>W\u00e4hle das Repository und den Zweig aus, von dem aus du die Anwendung bereitstellen m\u00f6chtest.<\/li>\n<li>Gib deiner Anwendung einen eindeutigen Namen und w\u00e4hle einen <strong>Standort im Rechenzentrum<\/strong>.<\/li>\n<li>Um die <strong>Build-Umgebung<\/strong> zu konfigurieren, w\u00e4hle die Option zur Verwendung einer <a href=\"https:\/\/docs.sevalla.com\/applications\/build-options\/dockerfile\"><strong>Dockerdatei<\/strong> um das Container-Image zu erstellen<\/a>.<\/li>\n<li>Gib den Pfad zu deiner Dockerdatei und den Kontext an.<\/li>\n<li>\u00dcberpr\u00fcfe die anderen Informationen und klicke auf <strong>Anwendung erstellen<\/strong>.<\/li>\n<\/ol>\n<h3>Teste den Microservice<\/h3>\n<p>Nach erfolgreicher Bereitstellung klickst du auf die angegebene <a href=\"https:\/\/flask-microservice-tutorial-3dhgr.kinsta.app\/\" target=\"_blank\" rel=\"noopener noreferrer\">URL<\/a>, um den Microservice zu testen, indem du HTTP-Anfragen in Postman stellst. Stelle eine <code>GET<\/code> Anfrage an den Root-Endpunkt.<\/p>\n<figure style=\"width: 1001px\" class=\"wp-caption alignnone\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/11\/testing-deployed-microservice.jpg\" alt=\"Erfolgreiche GET-Anfrage an die bereitgestellte Microservice-URL f\u00fcr die Home-Route\" width=\"1001\" height=\"471\"><figcaption class=\"wp-caption-text\">HTTP API <code>GET<\/code> Anfrage an den <code>product<\/code> Endpunkt des Microservices<\/figcaption><\/figure>\n<p>Um dich zu authentifizieren und ein JWT-Token zu generieren, sende eine <code>POST<\/code> Anfrage an den <code>\/auth<\/code> API-Endpunkt und \u00fcbergebe die Admin-Anmeldedaten im Body der Anfrage.<\/p>\n<figure style=\"width: 1001px\" class=\"wp-caption alignnone\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/11\/microservice-authentication.jpg\" alt=\"Eine POST-Anfrage an einen Microservice Auth Endpoint zur Authentifizierung in Postman\" width=\"1001\" height=\"471\"><figcaption class=\"wp-caption-text\">HTTP-API-Anfrage <code>POST<\/code> an den Endpunkt des Microservices <code>auth<\/code><\/figcaption><\/figure>\n<p>Nachdem du dich erfolgreich authentifiziert hast, stellst du eine <code>GET<\/code> Anfrage an den <code>\/products<\/code> Endpunkt, um Daten abzurufen.<\/p>\n<figure style=\"width: 1001px\" class=\"wp-caption alignnone\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/11\/products-list.jpg\" alt=\"Erfolgreiche HTTP-API-GET-Anfrage an den Produkt-Endpunkt in Postman\" width=\"1001\" height=\"471\"><figcaption class=\"wp-caption-text\">HTTP API <code>GET<\/code> Anfrage an einen Microservice <code>products<\/code> Endpunkt<\/figcaption><\/figure>\n<h2>Zusammenfassung<\/h2>\n<p>Da Anwendungen immer gr\u00f6\u00dfer und komplexer werden, ist es wichtig, Architekturmuster zu verwenden, die es erm\u00f6glichen, Softwaresysteme zu skalieren, ohne die verf\u00fcgbaren Ressourcen zu \u00fcberlasten.<\/p>\n<p>Die Microservice-Architektur bietet Skalierbarkeit, Entwicklungsflexibilit\u00e4t und Wartungsfreundlichkeit und erleichtert dir die Verwaltung komplexer Anwendungen.<\/p>\n<p>Kinsta vereinfacht den Prozess des Hostings deiner Microservices. Du kannst m\u00fchelos deine bevorzugte Datenbank verwenden und sowohl deine <a href=\"https:\/\/sevalla.com\/application-hosting\/\">Anwendung<\/a> als auch deine <a href=\"https:\/\/sevalla.com\/database-hosting\/\">Datenbank<\/a> bequem \u00fcber ein einheitliches Dashboard hosten.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>In der modernen Softwareentwicklung haben sich Microservices zu einer zentralen Architektur entwickelt, die Skalierbarkeit, Flexibilit\u00e4t und effizientes Management komplexer Systeme erm\u00f6glicht. Microservices sind kleine, unabh\u00e4ngige Anwendungen, &#8230;<\/p>\n","protected":false},"author":199,"featured_media":67563,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_kinsta_gated_content":false,"_kinsta_gated_content_redirect":"","footnotes":""},"tags":[],"topic":[937,973,974],"class_list":["post-67562","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","topic-docker","topic-postgresql","topic-python"],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v24.6 (Yoast SEO v24.6) - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Wie man Microservices mit Python erstellt und bereitstellt - Kinsta\u00ae<\/title>\n<meta name=\"description\" content=\"Lerne, wie du mit Python effiziente Microservices erstellst und bereitstellst, um die Entwicklung zu optimieren und die Leistung zu steigern!\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/kinsta.com\/de\/blog\/python-microservices\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Wie man Microservices mit Python erstellt und einsetzt\" \/>\n<meta property=\"og:description\" content=\"Lerne, wie du mit Python effiziente Microservices erstellst und bereitstellst, um die Entwicklung zu optimieren und die Leistung zu steigern!\" \/>\n<meta property=\"og:url\" content=\"https:\/\/kinsta.com\/de\/blog\/python-microservices\/\" \/>\n<meta property=\"og:site_name\" content=\"Kinsta\u00ae\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/Kinsta-Deutschland-207459890108303\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-12-05T12:25:35+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-12-28T15:23:11+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/python-microservices.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"3043\" \/>\n\t<meta property=\"og:image:height\" content=\"1522\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Jeremy Holcombe\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:description\" content=\"Lerne, wie du mit Python effiziente Microservices erstellst und bereitstellst, um die Entwicklung zu optimieren und die Leistung zu steigern!\" \/>\n<meta name=\"twitter:image\" content=\"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/python-microservices.jpg\" \/>\n<meta name=\"twitter:creator\" content=\"@Kinsta_DE\" \/>\n<meta name=\"twitter:site\" content=\"@Kinsta_DE\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Jeremy Holcombe\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"12\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/kinsta.com\/de\/blog\/python-microservices\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/kinsta.com\/de\/blog\/python-microservices\/\"},\"author\":{\"name\":\"Jeremy Holcombe\",\"@id\":\"https:\/\/kinsta.com\/de\/#\/schema\/person\/4eee42881d7b5a73ebb4f58dd5223b21\"},\"headline\":\"Wie man Microservices mit Python erstellt und einsetzt\",\"datePublished\":\"2023-12-05T12:25:35+00:00\",\"dateModified\":\"2023-12-28T15:23:11+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/kinsta.com\/de\/blog\/python-microservices\/\"},\"wordCount\":2162,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\/\/kinsta.com\/de\/#organization\"},\"image\":{\"@id\":\"https:\/\/kinsta.com\/de\/blog\/python-microservices\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/python-microservices.jpg\",\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/kinsta.com\/de\/blog\/python-microservices\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/kinsta.com\/de\/blog\/python-microservices\/\",\"url\":\"https:\/\/kinsta.com\/de\/blog\/python-microservices\/\",\"name\":\"Wie man Microservices mit Python erstellt und bereitstellt - Kinsta\u00ae\",\"isPartOf\":{\"@id\":\"https:\/\/kinsta.com\/de\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/kinsta.com\/de\/blog\/python-microservices\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/kinsta.com\/de\/blog\/python-microservices\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/python-microservices.jpg\",\"datePublished\":\"2023-12-05T12:25:35+00:00\",\"dateModified\":\"2023-12-28T15:23:11+00:00\",\"description\":\"Lerne, wie du mit Python effiziente Microservices erstellst und bereitstellst, um die Entwicklung zu optimieren und die Leistung zu steigern!\",\"breadcrumb\":{\"@id\":\"https:\/\/kinsta.com\/de\/blog\/python-microservices\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/kinsta.com\/de\/blog\/python-microservices\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\/\/kinsta.com\/de\/blog\/python-microservices\/#primaryimage\",\"url\":\"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/python-microservices.jpg\",\"contentUrl\":\"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/python-microservices.jpg\",\"width\":3043,\"height\":1522},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/kinsta.com\/de\/blog\/python-microservices\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/kinsta.com\/de\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Python\",\"item\":\"https:\/\/kinsta.com\/de\/thema\/python\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Wie man Microservices mit Python erstellt und einsetzt\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/kinsta.com\/de\/#website\",\"url\":\"https:\/\/kinsta.com\/de\/\",\"name\":\"Kinsta\u00ae\",\"description\":\"Schnelle, sichere und hochwertige Hosting-L\u00f6sungen\",\"publisher\":{\"@id\":\"https:\/\/kinsta.com\/de\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/kinsta.com\/de\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/kinsta.com\/de\/#organization\",\"name\":\"Kinsta\",\"url\":\"https:\/\/kinsta.com\/de\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\/\/kinsta.com\/de\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/kinsta-logo.jpeg\",\"contentUrl\":\"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/kinsta-logo.jpeg\",\"width\":500,\"height\":500,\"caption\":\"Kinsta\"},\"image\":{\"@id\":\"https:\/\/kinsta.com\/de\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/www.facebook.com\/Kinsta-Deutschland-207459890108303\/\",\"https:\/\/x.com\/Kinsta_DE\",\"https:\/\/www.instagram.com\/kinstahosting\/\",\"https:\/\/www.linkedin.com\/company\/kinsta\/\",\"https:\/\/www.pinterest.com\/kinstahosting\/\",\"https:\/\/www.youtube.com\/c\/Kinsta\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/kinsta.com\/de\/#\/schema\/person\/4eee42881d7b5a73ebb4f58dd5223b21\",\"name\":\"Jeremy Holcombe\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\/\/kinsta.com\/de\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/0e17001f3bb37dbbe54fceef9bb547fa?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/0e17001f3bb37dbbe54fceef9bb547fa?s=96&d=mm&r=g\",\"caption\":\"Jeremy Holcombe\"},\"description\":\"Senior Editor at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems.\",\"sameAs\":[\"https:\/\/www.linkedin.com\/in\/jeremyholcombe\/\"],\"url\":\"https:\/\/kinsta.com\/de\/blog\/author\/jeremyholcombe\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Wie man Microservices mit Python erstellt und bereitstellt - Kinsta\u00ae","description":"Lerne, wie du mit Python effiziente Microservices erstellst und bereitstellst, um die Entwicklung zu optimieren und die Leistung zu steigern!","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/kinsta.com\/de\/blog\/python-microservices\/","og_locale":"de_DE","og_type":"article","og_title":"Wie man Microservices mit Python erstellt und einsetzt","og_description":"Lerne, wie du mit Python effiziente Microservices erstellst und bereitstellst, um die Entwicklung zu optimieren und die Leistung zu steigern!","og_url":"https:\/\/kinsta.com\/de\/blog\/python-microservices\/","og_site_name":"Kinsta\u00ae","article_publisher":"https:\/\/www.facebook.com\/Kinsta-Deutschland-207459890108303\/","article_published_time":"2023-12-05T12:25:35+00:00","article_modified_time":"2023-12-28T15:23:11+00:00","og_image":[{"width":3043,"height":1522,"url":"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/python-microservices.jpg","type":"image\/jpeg"}],"author":"Jeremy Holcombe","twitter_card":"summary_large_image","twitter_description":"Lerne, wie du mit Python effiziente Microservices erstellst und bereitstellst, um die Entwicklung zu optimieren und die Leistung zu steigern!","twitter_image":"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/python-microservices.jpg","twitter_creator":"@Kinsta_DE","twitter_site":"@Kinsta_DE","twitter_misc":{"Verfasst von":"Jeremy Holcombe","Gesch\u00e4tzte Lesezeit":"12\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/kinsta.com\/de\/blog\/python-microservices\/#article","isPartOf":{"@id":"https:\/\/kinsta.com\/de\/blog\/python-microservices\/"},"author":{"name":"Jeremy Holcombe","@id":"https:\/\/kinsta.com\/de\/#\/schema\/person\/4eee42881d7b5a73ebb4f58dd5223b21"},"headline":"Wie man Microservices mit Python erstellt und einsetzt","datePublished":"2023-12-05T12:25:35+00:00","dateModified":"2023-12-28T15:23:11+00:00","mainEntityOfPage":{"@id":"https:\/\/kinsta.com\/de\/blog\/python-microservices\/"},"wordCount":2162,"commentCount":0,"publisher":{"@id":"https:\/\/kinsta.com\/de\/#organization"},"image":{"@id":"https:\/\/kinsta.com\/de\/blog\/python-microservices\/#primaryimage"},"thumbnailUrl":"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/python-microservices.jpg","inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/kinsta.com\/de\/blog\/python-microservices\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/kinsta.com\/de\/blog\/python-microservices\/","url":"https:\/\/kinsta.com\/de\/blog\/python-microservices\/","name":"Wie man Microservices mit Python erstellt und bereitstellt - Kinsta\u00ae","isPartOf":{"@id":"https:\/\/kinsta.com\/de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/kinsta.com\/de\/blog\/python-microservices\/#primaryimage"},"image":{"@id":"https:\/\/kinsta.com\/de\/blog\/python-microservices\/#primaryimage"},"thumbnailUrl":"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/python-microservices.jpg","datePublished":"2023-12-05T12:25:35+00:00","dateModified":"2023-12-28T15:23:11+00:00","description":"Lerne, wie du mit Python effiziente Microservices erstellst und bereitstellst, um die Entwicklung zu optimieren und die Leistung zu steigern!","breadcrumb":{"@id":"https:\/\/kinsta.com\/de\/blog\/python-microservices\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/kinsta.com\/de\/blog\/python-microservices\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/kinsta.com\/de\/blog\/python-microservices\/#primaryimage","url":"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/python-microservices.jpg","contentUrl":"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/python-microservices.jpg","width":3043,"height":1522},{"@type":"BreadcrumbList","@id":"https:\/\/kinsta.com\/de\/blog\/python-microservices\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/kinsta.com\/de\/"},{"@type":"ListItem","position":2,"name":"Python","item":"https:\/\/kinsta.com\/de\/thema\/python\/"},{"@type":"ListItem","position":3,"name":"Wie man Microservices mit Python erstellt und einsetzt"}]},{"@type":"WebSite","@id":"https:\/\/kinsta.com\/de\/#website","url":"https:\/\/kinsta.com\/de\/","name":"Kinsta\u00ae","description":"Schnelle, sichere und hochwertige Hosting-L\u00f6sungen","publisher":{"@id":"https:\/\/kinsta.com\/de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/kinsta.com\/de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/kinsta.com\/de\/#organization","name":"Kinsta","url":"https:\/\/kinsta.com\/de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/kinsta.com\/de\/#\/schema\/logo\/image\/","url":"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/kinsta-logo.jpeg","contentUrl":"https:\/\/kinsta.com\/de\/wp-content\/uploads\/sites\/5\/2023\/12\/kinsta-logo.jpeg","width":500,"height":500,"caption":"Kinsta"},"image":{"@id":"https:\/\/kinsta.com\/de\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/Kinsta-Deutschland-207459890108303\/","https:\/\/x.com\/Kinsta_DE","https:\/\/www.instagram.com\/kinstahosting\/","https:\/\/www.linkedin.com\/company\/kinsta\/","https:\/\/www.pinterest.com\/kinstahosting\/","https:\/\/www.youtube.com\/c\/Kinsta"]},{"@type":"Person","@id":"https:\/\/kinsta.com\/de\/#\/schema\/person\/4eee42881d7b5a73ebb4f58dd5223b21","name":"Jeremy Holcombe","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/kinsta.com\/de\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/0e17001f3bb37dbbe54fceef9bb547fa?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/0e17001f3bb37dbbe54fceef9bb547fa?s=96&d=mm&r=g","caption":"Jeremy Holcombe"},"description":"Senior Editor at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems.","sameAs":["https:\/\/www.linkedin.com\/in\/jeremyholcombe\/"],"url":"https:\/\/kinsta.com\/de\/blog\/author\/jeremyholcombe\/"}]}},"acf":[],"_links":{"self":[{"href":"https:\/\/kinsta.com\/de\/wp-json\/wp\/v2\/posts\/67562","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/kinsta.com\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/kinsta.com\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/kinsta.com\/de\/wp-json\/wp\/v2\/users\/199"}],"replies":[{"embeddable":true,"href":"https:\/\/kinsta.com\/de\/wp-json\/wp\/v2\/comments?post=67562"}],"version-history":[{"count":6,"href":"https:\/\/kinsta.com\/de\/wp-json\/wp\/v2\/posts\/67562\/revisions"}],"predecessor-version":[{"id":68026,"href":"https:\/\/kinsta.com\/de\/wp-json\/wp\/v2\/posts\/67562\/revisions\/68026"}],"alternate":[{"embeddable":true,"hreflang":"en","title":"English","href":"https:\/\/kinsta.com\/de\/wp-json\/kinsta\/v1\/posts\/67562\/translations\/en"},{"embeddable":true,"hreflang":"pt","title":"Portuguese","href":"https:\/\/kinsta.com\/de\/wp-json\/kinsta\/v1\/posts\/67562\/translations\/pt"},{"embeddable":true,"hreflang":"fr","title":"French","href":"https:\/\/kinsta.com\/de\/wp-json\/kinsta\/v1\/posts\/67562\/translations\/fr"},{"embeddable":true,"hreflang":"de","title":"German","href":"https:\/\/kinsta.com\/de\/wp-json\/kinsta\/v1\/posts\/67562\/translations\/de"},{"embeddable":true,"hreflang":"ja","title":"Japanese","href":"https:\/\/kinsta.com\/de\/wp-json\/kinsta\/v1\/posts\/67562\/translations\/jp"},{"embeddable":true,"hreflang":"es","title":"Spanish","href":"https:\/\/kinsta.com\/de\/wp-json\/kinsta\/v1\/posts\/67562\/translations\/es"},{"embeddable":true,"hreflang":"it","title":"Italian","href":"https:\/\/kinsta.com\/de\/wp-json\/kinsta\/v1\/posts\/67562\/translations\/it"},{"href":"https:\/\/kinsta.com\/de\/wp-json\/kinsta\/v1\/posts\/67562\/tree"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/kinsta.com\/de\/wp-json\/wp\/v2\/media\/67563"}],"wp:attachment":[{"href":"https:\/\/kinsta.com\/de\/wp-json\/wp\/v2\/media?parent=67562"}],"wp:term":[{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/kinsta.com\/de\/wp-json\/wp\/v2\/tags?post=67562"},{"taxonomy":"topic","embeddable":true,"href":"https:\/\/kinsta.com\/de\/wp-json\/wp\/v2\/topic?post=67562"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}