WordPress ist ein leistungsstarkes Content Management System (CMS), das die Grundlage für verschiedene Arten von Websites und Anwendungen bilden kann. Es verwendet eine typische „monolithische Architektur“, aber wenn eine Website wächst, ist das vielleicht nicht mehr die beste Lösung. In diesem Fall kann eine „Microservices-Architektur“ von Vorteil sein.
In diesem Beitrag erfahren wir, wie du WordPress-Webanwendungen mit einer Microservices-Architektur erstellen kannst. Außerdem stellen wir dir das Create Block Theme Plugin vor und besprechen, wie diese spannende Lösung in deine Entwicklung passt.
Was Microservices sind
Bevor du eine Web-Anwendung entwickelst, solltest du verstehen, was Microservices sind und wie sie sich von monolithischen Architekturen unterscheiden.
Bei einer monolithischen Architektur sind alle Komponenten einer Anwendung eng miteinander verbunden. Sie läuft im Wesentlichen als ein einziger Dienst. Das ist eine einfache Art, eine Anwendung zu entwickeln, obwohl Wartung und Skalierbarkeit mit zunehmender Komplexität zu einer Herausforderung werden können.
Mit Microservices hingegen kannst du die Anwendung in eine Sammlung kleinerer Dienste aufteilen. Jeder Dienst ist in Bezug auf Entwicklung, Bereitstellung und Skalierung unabhängig voneinander.
Jeder Dienst übernimmt eine bestimmte Aufgabe und kommuniziert mit den anderen Diensten über eine Anwendungsprogrammierschnittstelle (API). Betrachte zum Beispiel eine typische E-Commerce-Website mit Warenkorb, Kasse, Bestellabwicklung, Produktseite und mehr.
In einer monolithischen Architektur wären all diese Funktionen Teil einer einzigen, großen Anwendung. WordPress ist monolithisch, und Woocommerce als E-Commerce-Plattform ist ein hervorragendes Beispiel dafür.
Mit einer Microservices-Architektur kannst du jedoch für jede Aufgabe die richtige Technologie einsetzen. Du könntest zum Beispiel das erstklassige CMS von WordPress für dein Content Marketing nutzen. Adobe Commerce könnte dein Produktmanagementsystem sein. Eine Checkout-Lösung wie Bolt könnte für deine Bedürfnisse geeignet sein.
Mit Microservices ist es möglich, diese miteinander zu verbinden. Als Nächstes wollen wir uns genauer ansehen, warum Microservices für dein nächstes Projekt eine wichtige Rolle spielen sollten.
Was Microservices von monolithischen Architekturen abhebt
Das Hauptargument für Microservices ist, dass du verschiedene Technologien und Werkzeuge zu einem Ganzen kombinieren kannst. Es gibt jedoch noch weitere, tiefer gehende Merkmale, die es wert sind, beachtet zu werden:
- Entkopplung. Jeder Dienst behält seine Unabhängigkeit. Das bedeutet, dass du für jede Aufgabe die beste Technologie einsetzen kannst, anstatt dich mit unpassenden Frameworks herumzuschlagen.
- Eigenständigkeit. Die Dienste, die du integrierst, müssen nicht voneinander abhängig sein, um performant zu sein.
- Spezialisierung. Jeder Dienst konzentriert sich auf seine eigene Aufgabe, was sich wiederum auf die Leistung auswirkt.
- Ausfallsicherheit. Ein Teil dieses inhärenten und leistungsfähigen Vorteils besteht darin, dass der Ausfall eines Dienstes nicht deine gesamte Website zum Erliegen bringt.
Neben diesen Aspekten gibt es noch weitere Vorteile beim Einsatz von Microservices:
- Skalierbarkeit. Du kannst einzelne Dienste je nach Bedarf skalieren, ohne den Rest deiner Anwendung zu beeinträchtigen.
- Flexibilität. Wir haben bereits kurz beschrieben, wie deine Dienste die beste Technologie für ihre Aufgabe nutzen können. Das gilt sogar für die Programmiersprachen, mit denen du sie erstellst.
- Schnellere Entwicklung. Du kannst kleine und fokussierte Dienste schneller entwickeln, die Funktionen deines Dienstes besser verstehen und das System einfacher warten.
- Verbesserte Fehlereingrenzung. Durch den „modularen“ Aufbau kannst du einen Dienst isolieren, wenn er ausfällt, ohne dass deine anderen Dienste davon betroffen sind.
Andererseits können Microservices die Kommunikation, die Datenkonsistenz und die Verwaltung verteilter Systeme komplexer machen. Deshalb musst du die Anforderungen deiner Anwendung sorgfältig abwägen. Kurz gesagt: Wäge sowohl die Vorteile als auch die Nachteile ab, bevor du dich für den Einsatz von Microservices entscheidest.
Die Komponenten einer Microservices-Architektur
Wie zu erwarten, kann eine Microservices-Architektur aus mehreren Komponenten bestehen. Diese „Rädchen“ arbeiten im gesamten „System“ zusammen, um eine skalierbare und wartbare Anwendung zu ermöglichen.
Es gibt also einige Komponenten, die für eine reibungslose Umsetzung entscheidend sind:
- API-Gateway: Dies ist der Eingangspunkt für alle Kundenanfragen. Er leitet diese Anfragen an die entsprechenden Microservices weiter. Er kann auch Aufgaben wie die Ratenbegrenzung und die Authentifizierung übernehmen.
- Service Discovery: Du musst einen dynamischen Weg finden, damit die Microservices einander entdecken und miteinander kommunizieren können. Tools wie Consul oder Eureka können dabei helfen.
- Containerisierung: Es ist üblich, Microservices mit Tools wie Docker als Container zu verpacken und bereitzustellen. So sorgst du für die Isolierung der einzelnen Dienste.
- Orchestrierung: Je mehr Microservices du zu deiner Anwendung hinzufügst, desto komplexer wird ihre Verwaltung. Ein Tool wie Kubernetes kann dabei helfen, die Verwaltung dieser Dienste zu automatisieren.
- Caching: Caching-Mechanismen wie Redis oder Memcached verbessern oft die Leistung. Das kann entscheidend sein, wenn deine Backend-Dienste und Datenbanken stärker belastet werden.
- Nachrichtenübermittlung: Natürlich müssen deine Dienste auch miteinander kommunizieren. Dafür gibt es „asynchrone“ Messaging-Lösungen wie RabbitMQ oder Apache Kafka. Diese „Message-Broker“ ermöglichen eine lose Kopplung zwischen deinen Microservices.
Die Tools sind jedoch nur ein Aspekt deiner Einrichtung. Es gibt noch weitere Überlegungen, z. B. wie du die einzelnen Microservices innerhalb der Gesamtarchitektur gestalten willst.
Entwurfsmuster für Microservices
Deine Entwurfsmuster für Microservices sind hier genauso wichtig wie in anderen Bereichen deines Entwicklungsprozesses. Angesichts der potenziellen Komplexität deiner Anwendung ist es wichtig zu überlegen, welche Muster den größten Einfluss haben werden. Drei davon können wir hervorheben:
- Datenbank-per-Service: Jeder Microservice verwendet seine eigene Datenbank, was zur Datenisolierung und Autonomie beiträgt.
- API-Komposition: Du kannst Microservices zusammenstellen, um übergeordnete Dienste oder APIs zu erstellen. Diese Flexibilität und Wiederverwendbarkeit ist ein großer Vorteil.
- Ereignisgesteuerte Architektur: Hier kommunizieren die Dienste über Ereignisse. Dies ermöglicht eine lockerere Kopplung und asynchrone Verarbeitung.
Es ist auch wichtig, dass du die spezifischen Entwurfsmuster der Tools berücksichtigst, die du für den Aufbau deiner Architektur verwendest. Docker und Kubernetes zum Beispiel haben beide typische Muster, die du neben dem globalen Design deiner Architektur berücksichtigen musst.
Du musst dir jedoch darüber im Klaren sein, dass nicht jede Komponente ein Microservice sein muss. Die richtige Idee ist es, mit den wichtigsten Diensten zu beginnen und die Architektur im Laufe der Zeit weiterzuentwickeln. Später werden wir das noch genauer besprechen. Zunächst sollten wir uns ansehen, wie wir das Frontend entwickeln.
Einführung in das Plugin Create Block Theme
WordPress wird wahrscheinlich irgendwo in deiner Architektur vorkommen, da es in vielerlei Hinsicht hervorragend ist. Eine davon ist die Benutzerfreundlichkeit des Frontends. Themes sind ein zentraler Bestandteil der Plattform, und die Erstellung eigener Themes ist jetzt viel einfacher, da es Plugins wie Create Block Theme gibt.
Dieses Plugin ist der geistige Nachfolger des Underscores Starter-Theme, ist aber vollständig mit der gesamten Website-Bearbeitung (FSE) kompatibel. Du kannst schnell ein Starter-Theme erstellen, die volle Leistung des Editors nutzen und alle Anpassungsmöglichkeiten ausschöpfen. Es funktioniert wie ein typisches WordPress-Plugin mit der Option, es später als eigenständiges Theme zu exportieren.
Wenn du das Block-Theme-Plugin zusammen mit einer Microservices-Architektur verwendest, kann alles miteinander verbunden werden. Du könntest zum Beispiel Block Patterns und wiederverwendbare Blöcke auf verschiedenen WordPress-Websites verwenden. Das fördert nicht nur die Wiederverwendung und Konsistenz des Codes, sondern sorgt auch für ein einheitliches Erscheinungsbild der einzelnen Dienste, die du nutzt.
Auf die Einzelheiten der Verwendung von Create Block Theme werden wir später in diesem Beitrag eingehen. Jetzt wollen wir erst einmal über Headless WordPress sprechen und darüber, wie Microservices es beeinflussen können.
Die Überschneidung zwischen Headless WordPress und einer Microservices-Architektur
Wenn du das Front- und Backend von WordPress entkoppeln willst, sind Microservices ein natürlicher Schritt nach vorne. Bei einem typischen Headless WordPress dient die Plattform nur zur Verwaltung von Inhalten. Es könnte sein, dass sie als API verwendet wird.
Durch die Kombination von Headless WordPress mit einer Microservices-Architektur kannst du:
- Die WordPress REST API nutzen. WordPress bietet eine integrierte REST-API, mit der du Inhalte programmatisch abrufen und bearbeiten kannst. Du kannst diese API nutzen, um deine Microservices in WordPress zu integrieren.
- Unabhängige Skalierbarkeit von Front- und Backend. Mit zwei unabhängigen Teilen deiner Website kannst du beide skalieren und eine bessere Leistung erzielen. Trotz der Komplexität erhältst du tatsächlich Flexibilität.
Als Nächstes wollen wir uns ein wenig mehr mit der REST-API beschäftigen. Über sie werden die Microservices genutzt, sie ist also ein wichtiger Teil der gesamten Kette.
Microservices und die WordPress REST API
Die WordPress REST API spielt eine entscheidende Rolle bei der Integration zwischen deiner Website und den Microservices. Mit ihren Endpunkten kannst du WordPress-Beiträge, -Seiten, -Benutzer, -Taxonomien und vieles mehr abrufen und bearbeiten, indem du JSON-Daten ausgibst.
[
{
"id": 1,
"date": "2020-04-01T10:30:00",
"date_gmt": "2020-04-01T14:30:00",
"guid": {
"rendered": "https://example.com/?p=1"
},
"modified": "2020-04-01T10:30:00",
"modified_gmt": "2020-04-01T14:30:00",
"slug": "hello-world",
"status": "publish",
"type": "post",
"link": "https://example.com/hello-world/",
"title": {
"rendered": "Hello World"
},
…Die REST-API ist somit der Knotenpunkt für alle anderen Dienste in der Architektur. Das bedeutet, dass du auswählen musst, welche aktuellen Webseitendienste du als Microservices extrahieren willst. Wir werden uns das später in diesem Beitrag genauer ansehen.
Kurz gesagt, geht es darum, die verschiedenen Funktionen und Verantwortlichkeiten innerhalb deiner Web-Anwendung zu identifizieren. Von dort aus kannst du sie in unabhängige, fokussierte und einsatzfähige Microservices aufteilen.
Aufbau einer Webanwendung mit Create Block Theme und Microservices
Der Rest dieses Beitrags befasst sich mit den Grundlagen von Microservices und Headless WordPress. Vieles wird ganzheitlich behandelt, denn der eigentliche Prozess wird auf deine Bedürfnisse zugeschnitten sein.
Trotzdem wollen wir uns mit dem Aufbau einer Web-Anwendung mithilfe von Microservices und dem Create Block Theme Plugin beschäftigen. Der erste Schritt besteht darin, deine Entwicklungsumgebung einzurichten.
1. Eine Entwicklungsumgebung einrichten
Jede Anwendung beginnt mit einer Umgebung, in der sie erstellt werden kann. Deshalb brauchst du eine Entwicklungsumgebung. Es gibt zwei Orte für deine Entwicklungsumgebung: deinen lokalen Computer und deinen Server.
Es gibt viele Möglichkeiten, eine lokale Entwicklungsumgebung einzurichten, aber wir empfehlen (natürlich) DevKinsta:
Wir empfehlen auch eine Staging-Umgebung, denn du brauchst eine Möglichkeit, um Änderungen zu testen, bevor du sie einsetzt. Wenn du DevKinsta wählst und Kinsta-Kunde bist, erhältst du eine bessere Anbindung an deinen Server:
DevKinsta installiert Docker für dich, was dir hilft, eine weitere Aufgabe von deiner Liste zu streichen. Wenn du Kubernetes für die Orchestrierung nutzen willst, ist jetzt der richtige Zeitpunkt, es zu installieren. Kinsta nutzt Kubernetes für Datenbankanwendungen und andere Aufgaben. Du kannst es mit Docker Desktop herunterladen:
Von hier aus musst du auch alle anderen Frameworks einrichten, die du für die Entwicklung deines Themas brauchst. Ohne das Plugin „Create Block Theme“ kannst du jedoch nichts tun, also schauen wir uns das jetzt an.
2. Das Create Block Theme-Plugin einrichten
Sobald du deine Entwicklungsumgebung eingerichtet hast, kannst du mit dem Plugin „Create Block Theme“ arbeiten, um dein eigenes blockbasiertes Theme zu erstellen. Außerdem brauchst du Folgendes:
- Eine WordPress-Website, mit der du arbeiten kannst.
- Einen Editor, den du gerne verwendest.
- Das Plugin „Create Block Theme“.
Du kannst das Plugin auf die für WordPress typische Weise installieren. Gehe dann in WordPress auf den Link Appearance > Create Block Theme:
Nebenbei bemerkt, kannst du auf der Registerkarte Appearance die Option Manage Theme Fonts entdecken. Über den Link Block-Theme erstellen kannst du auch auf diese Option zugreifen, die im Wesentlichen die Schriftartenbibliothek von WordPress 6.5 ist.
Auf dem Bildschirm „Blocktheme erstellen“ solltest du eine Liste mit Optionen sehen, mit denen du ein neues Thema erstellen kannst. Wir werden sie hier nicht alle durchgehen, aber wir werden uns für das Klonen von Twenty Twenty-Four entscheiden. In jedem Fall werden eine Reihe von Optionen und Feldern angezeigt:
Wie du siehst, werden dies die Felder für die Themenidentität in deiner style.css Datei sein. Sie sind einfach und bestehen aus einem Namen, einem Screenshot, einer URL und einigen Tags für das WordPress-Themenverzeichnis.
Wenn du auf „Bestätigen“ klickst, gehst du wieder zum Bildschirm Erscheinungsbild > Themen und siehst dein neues Theme bereitstehen:
In manchen Fällen lädst du eine ZIP-Datei deines Themes herunter, die du wieder in WordPress hochladen solltest. Du kannst das Theme auch exportieren, aber für unseren Anwendungsfall werden wir das jetzt nicht tun.
Tipps für die Einrichtung und Verwendung von Create Block Theme
Wir werden auch nicht zu sehr auf die Anpassung deines neuen Block-Themes eingehen, denn das würde den Rahmen dieses Beitrags sprengen. Hier sind jedoch einige Tipps für die Verwendung des Block-Designs:
- Deine Änderungen können an zwei Stellen vorgenommen werden. Du kannst entweder die Option Globale Stile im Full Site Editor verwenden oder die Datei theme.json anpassen.
- Es ist eine gute Idee, einen Block für deinen gewählten Microservice zu erstellen. Darauf gehen wir später noch näher ein.
- Mit Block-Theme erstellen kannst du ein Child-Theme erstellen, das auf dem aktuellen aktiven Theme basiert. Deine Wahl hängt jedoch von deinen Zielen ab.
Lass uns über den letzten Punkt etwas mehr sprechen. Wenn du ein Theme erstellen und verbreiten willst, solltest du mit dem übergeordneten Theme arbeiten. Für deinen eigenen Gebrauch kannst du auch nur das Child-Theme anpassen. Als Faustregel gilt: Je weniger „bevölkert“ ein Theme zu Beginn ist, desto mehr solltest du mit dem Eltern-Theme arbeiten.
3. Extrahieren deiner ausgewählten Microservices
Sobald dein Block-Theme einsatzbereit ist, ist es an der Zeit, deine Microservices genauer unter die Lupe zu nehmen. Eine wichtige Entscheidung, die du treffen musst, ist, welche Dienste zu „Microservices“ werden sollen
Das kann eine komplexe und subjektive Frage sein, die du nach deinen eigenen Bedürfnissen beantworten musst. Es gibt jedoch ein paar Faktoren, die du beachten solltest:
- Die Fähigkeiten deiner Website: Wenn deine Website besondere Funktionen bietet, solltest du überlegen, ob du sie in einen separaten Microservice aufteilst, z. B. die Zahlungsfunktion.
- Unabhängige Skalierbarkeit: Ein bestehender Dienst, der auf unabhängige Skalierung angewiesen ist, ist ein guter Kandidat für Microservices. Caching könnte hier ein Beispiel sein.
- Technologievielfalt: Wenn du dich von der PHP-Architektur von WordPress wegbewegen musst, ist dies ebenfalls ein Kandidat für einen Microservice. Das könnte bei bestimmten E-Commerce-Plattformen oder Backend-Komponenten der Fall sein.
- Datenisolierung: Dienste mit speziellen Anforderungen an die Datenspeicherung könnten Microservices sein. Dies ist auch der Fall, wenn diese Dienste keine Daten mit anderen teilen müssen.
Unserer Meinung nach ist es eine gute Idee, Microservices zu erstellen, die bestimmte API-Funktionen bereitstellen. Das kann die Suche, die Zahlungsabwicklung oder die Authentifizierung sein. Wenn diese Dienste mit anderen APIs von Erst- und Drittanbietern reagieren können, werden sie flexibler und wertvoller.
Entwickeln und Bereitstellen deiner Microservices
Um deine Microservices zu entwickeln und schließlich bereitzustellen, musst du dich auf andere Tools verlassen. Hier sind einige wichtige Überlegungen und Tools, die du verwenden kannst:
- Docker wird oft die Art und Weise sein, wie du deine Microservices containerisierst. Es packt den Microservice und seine Abhängigkeiten zusammen und macht die Bereitstellung und Skalierung einfach.
- Jeder Microservice braucht auch ein Dockerfile. Darin solltest du die notwendigen Abhängigkeiten, Konfigurationen und die Laufzeitumgebung angeben.
- Nutze Kubernetes für die Container-Orchestrierung und -Verwaltung. Kinsta bietet eine leistungsstarke Plattform mit integrierter Unterstützung für Kubernetes.
- Mit Continuous Integration and Deployment (CI/CD) Pipelines kannst du die Erstellung, das Testen und die Bereitstellung automatisieren. Tools wie GitLab und Travis CI können dabei helfen, deine CI/CD-Prozesse zu rationalisieren.
- Serverlose Funktionen benötigen keinen vollwertigen Server und eignen sich daher hervorragend für Microservices. Plattformen wie AWS Lambda, Google Cloud Functions oder Azure Functions ermöglichen es dir, Code auszuführen, ohne Server bereitzustellen oder zu verwalten.
- API-Gateways bieten einen einzigen Einstiegspunkt für deine Microservices. Tools wie Kong oder Amazon API Gateway helfen dir bei der Verwaltung und Sicherung deiner APIs. Außerdem können sie Aufgaben wie Authentifizierung, Ratenbegrenzung und Request Routing übernehmen.
Jetzt hast du eine WordPress-Website und einen Microservice, die unabhängig voneinander sind. Der letzte Schritt besteht darin, sie zu integrieren.
4. Integration von Microservices in WordPress
Sobald du deine Microservices entwickelt und bereitgestellt hast, musst du sie in WordPress integrieren. Dazu musst du API-Aufrufe von WordPress zu den Endpunkten deines Microservices tätigen. Dazu musst du die REST-API in- und auswendig kennen.
In WordPress kannst du das in der Regel mit wp_remote_get() oder wp_remote_post() tun. Damit kannst du HTTP-Anfragen senden und die Antworten verarbeiten. Hier ist ein Beispielcode, der zeigt, wie das alles zusammenpasst:
// API endpoint URL
$api_url = 'https://api.example.com/endpoint';
// API request parameters
$params = array(
'param1' => 'value1',
'param2' => 'value2',
);
// Make the API request using wp_remote_get
$response = wp_remote_get(add_query_arg($params, $api_url));
// Check if the request was successful
if (is_wp_error($response)) {
// Handle the error
$error_message = $response->get_error_message();
// Log or display the error message
} else {
// Process the API response
$response_body = wp_remote_retrieve_body($response);
$data = json_decode($response_body, true);
// Use the retrieved data as needed
// ...
}
Microservices profitieren oft vom asynchronen Abrufen von Daten, damit der Hauptthread nicht blockiert wird. WordPress kann zwei Elemente kombinieren, um dies zu erreichen. Du kannst das API Fetch-Paket zusammen mit der in WordPress 6.3 eingeführten Unterstützung für async und defer verwenden. Dein Code könnte in etwa so aussehen wie der folgende:
import apiFetch from '@wordpress/api-fetch';
// Microservice API endpoint URL
const microserviceUrl = 'https://api.example.com/microservice';
...
// Make the API request to the microservice
apiFetch({
path: microserviceUrl,
method: 'GET',
data: params,
})
.then((response) => {
// Process the response
console.log(response);
// Use the retrieved data from the microservice
// ...
})
...
Du könntest auch AJAX in Betracht ziehen, um dynamische Aktualisierungen der Benutzeroberfläche (UI) durchzuführen.
Natürlich sind auch die richtige Authentifizierung und Sicherheitsmaßnahmen wichtig. Die WordPress REST-API bietet einige Möglichkeiten zur Authentifizierung von Sitzungen, z. B. mit Cookies, JSON Web Tokens (JWT) oder Anwendungspasswörtern. Da du auf externe Lösungen angewiesen bist, ist die Sicherheit deiner Microservices und deiner Website von entscheidender Bedeutung.
Da wir ein benutzerdefiniertes Block-Theme verwenden, ist es sinnvoll, diese Funktion zu nutzen. Wenn du deinen Microservice zu einem Block hinzufügst, kannst du ihn fast überall auf deiner Website einbinden. Wenn du noch einen Schritt weiter gehen willst, kannst du diese Funktion sogar in ein Plugin integrieren.
Der Prozess besteht aus drei Komponenten: Registrierung des Blocks, Rendering des Inhalts und Verarbeitung der Daten. JavaScript ist hier die Sprache deiner Wahl, und die Funktion registerBlockType übernimmt die Registrierung und das Rendering:
// JavaScript function that builds the Block to enable access within the Block Editor.
( function( blocks, element ) {
var el = element.createElement;
blocks.registerBlockType( 'my-micro/stripe-api', {
title: 'Stripe Payment Gateway',
icon: 'dashicons-cart',
category: 'embed',
edit: function() {
return el(
'div',
{},
'' // Create the visual elements of the microservice to display within the Block Editor.
);
},
…
Dies ist ein sehr einfaches Beispiel für die Registrierung eines Blocks, und alles Weitere würde den Rahmen dieses Beitrags sprengen. Du kannst jedoch sehen, dass es ganz einfach ist, das Create Block Theme Plugin, Microservices und WordPress zu kombinieren. Wenn du den richtigen Hosting-Anbieter nutzt, hast du eine weitere Möglichkeit, deine Microservice-Architektur aufzuwerten.
Mit Kinsta deine WordPress-Website und Microservices verwalten und skalieren
Das gesamte Ökosystem von Kinsta eignet sich hervorragend für die Verwaltung von WordPress-Sites mit einer Microservice-Architektur. Das Herzstück ist das Anwendungs-Hosting. Das macht es einfach, Microservices in Containern bereitzustellen und sie dann mit den anderen Angeboten von Kinsta zu verwalten.
Die automatische Skalierung überwacht zum Beispiel deine Ressourcen, um Traffic-Spitzen zu bewältigen. Das bedeutet, dass deine Microservices je nach Bedarf nach oben oder unten skaliert werden können. Du profitierst von den Leistungsvorteilen und hältst gleichzeitig die Kosten niedrig.
Kinsta bietet Managed Hosting für eine Reihe von Datenbanktypen:
Redis kann für verschiedene Zwecke eingesetzt werden, z. B. als In-Memory-Cache, Message-Broker, Vektor- und Dokumentendatenbank und vieles mehr – und das alles ohne die Notwendigkeit von SQL.
Diese Vielfalt bedeutet, dass Kinsta sowohl deine WordPress- als auch deine Microservice-Datenbanken bedienen kann, ohne dass du ins Schwitzen kommst. Zusammen mit dem erstklassigen Caching, der Unterstützung von Docker und Kubernetes, dem übersichtlichen MyKinsta-Dashboard und vielem mehr hast du das komplette Paket, um deine Microservices neben WordPress zu hosten.
Zusammenfassung
WordPress ist monolithisch, aber das hindert es nicht daran, Microservices einzubinden. Das kann viele Vorteile haben, z. B. eine bessere Skalierbarkeit, Flexibilität und schnellere Entwicklung.
Mit dem Plugin Create Block Theme kannst du eine saubere, sichere Codebasis für den Rest deines Projekts erstellen. Microservices können deine Website komplex machen. Mit einem benutzerdefinierten Block-Theme kannst du diese Dienste auf die für dich am besten geeignete Weise implementieren. Wenn du dies mit Entwicklungstools wie DevKinsta und dem Anwendungs-Hosting von Kinsta kombinierst, hast du die ideale Grundlage für die Erstellung leistungsstarker, moderner Webanwendungen.
Scheint eine Microservices-Architektur perfekt zum Create Block Theme Plugin zu passen? Lass uns deine Gedanken und Erfahrungen in den Kommentaren unten wissen!
Schreibe einen Kommentar