In der Python-Welt lieben viele Entwickler die NoSQL-Datenbank Redis wegen ihrer Geschwindigkeit und der Verfügbarkeit einer robusten Auswahl an Client-Bibliotheken. In der WordPress-Welt ist Redis oft die erste Wahl, wenn ein persistenter Objekt-Cache benötigt wird, um den Datenzugriff im Backend zu beschleunigen.

Du kannst diese beiden Welten zusammenbringen, wenn du die WordPress-Inhalte mit einer Python-Anwendung bearbeitest.

In diesem Leitfaden zeigen wir dir, wie du Inhalte direkt in Redis posten kannst, indem du eine Python-Anwendung erstellst, die die beliebte Bibliothek redis-py nutzt, und wie du über die WordPress REST API posten kannst.

Was ist Redis?

Redis (Remote Dictionary Server) ist eine schnelle NoSQL-Datenbank und ein In-Memory-Cache, der von Salvatore Sanfilippo entwickelt und von Redis Ltd. (ehemals Redi Labs) gewartet. Die Open-Source-Versionen von Redis sind unter der Berkeley Source Distribution (BSD)-Lizenz erhältlich, während Redis Ltd. auch kommerzielle Unternehmens- und Cloud-Versionen des Servers anbietet.

Redis unterscheidet sich von anderen NoSQL-Datenbanken durch seinen Datenspeichermechanismus. Er wird üblicherweise als Datenstrukturspeicher bezeichnet, weil er Daten mit denselben Datentypen speichert, die in vielen Programmiersprachen vorkommen, z. B. Strings, Sets, Listen und Dictionaries (oder Hashes). Redis unterstützt nicht nur einfache Strukturen, sondern auch fortgeschrittene Datenstrukturen für Aufgaben wie Geolocation und Stream Processing.

Voraussetzungen für Python-Anwendungen

Bevor du mit der Erstellung deiner Anwendung beginnst, musst du die folgenden drei Dinge lokal installieren:

Pro-Tipp: Du kannst diese Entwicklungsumgebung ganz einfach in Docker erstellen, indem du das WordPress-fertige DevKinsta-Paket von Kinsta installierst.

Nachdem die Voraussetzungen installiert sind, ist es an der Zeit, die Dinge zum Laufen zu bringen. Konkret erstellst du eine Python-Anwendung, die die WordPress-Beiträge eines Nutzers im Wörterbuchformat in einem Redis-Cache speichert.

Eine Python-Anwendung erstellen, um einen Beitrag im Redis-Cache zu speichern

Der Redis-Cache ist ein effizienter Caching-Mechanismus für Websites. Er speichert häufig angefragte Informationen, um einen schnelleren und bequemeren Zugriff zu ermöglichen. Der Cache speichert Informationen in einer Key-Value-Datenstruktur.

Beginne damit, einen neuen Ordner für dein Projekt mit dem Namen python-redis zu erstellen. Starte dann dein Kommandoterminal, gehe auf cd zu python-redis und installiere redis-py, indem du den folgenden Befehl ausführst:

pip install redis

Wenn die Installation abgeschlossen ist, erstelle eine neue Datei namens main.py im Verzeichnis python-redis. Öffne die Datei in deinem bevorzugten Texteditor und gib die unten stehenden Codeblöcke ein.

Beginne damit, die neu installierte redis-py-Bibliothek zu importieren und lege den Redis-Host und die Portadresse fest:

import redis
redis_host = 'localhost'
redis_port = 6379

Nun definierst du die Werte für den WordPress-Beitrag als Schlüssel/Wert-Paare in einem Wörterbuch. Hier ist ein Beispiel:

post = {
    'ID': 1,
    'post_author': 1,
    'post_date': '2024-02-05 00:00:00',
    'post_date_gmt': '2024-02-05 00:00:00',
    'post_content': 'Test Post <br/><a href="http://www.my-site.com/">related blog post</a>',
    'post_title': 'My first post',
    'post_excerpt': 'In this post, I will...',
    'post_status': 'publish',
    'comment_status': 'open',
    'ping_status': 'open',
    'post_password': 'my-post-pwd',
    'post_name': 'my-first-post',    
}

Hinweis: In einer realen Anwendung würde der Inhalt des Beitrags wahrscheinlich aus einem HTML-Eingabeformular stammen.

Ergänze den Code mit einer redis_dict() Funktion, die eine Verbindung zu deinem lokalen Redis-Server herstellt, den obigen Beitrag im Redis-Cache speichert und die erfolgreich erstellten Werte auf der Konsole ausgibt:

def redis_dict():
    try:
        r = redis.StrictRedis(host = redis_host, port = redis_port, decode_responses=True)
        r.hset("newPostOne", mapping=post)
        msg = r.hgetall("newPostOne")
        print(msg)
    except Exception as e:
        print(f"Something went wrong {e}")

# Runs the function:
if __name__ == "__main__":
    redis_dict()

Wenn du Redis nicht innerhalb von Docker gestartet hast, rufst du die Redis-Befehlszeilenschnittstelle mit dem folgenden Befehl auf:

redis-cli

Führe nun dein Python-Skript aus:

python main.py

Wenn du das Skript ausführst, wird der Beitrag zum Redis-Schlüsselwertspeicher hinzugefügt. Du solltest die folgende Antwort in der Konsole deines Terminals sehen:

Die Konsolenausgabe zeigt an, dass die Python-Anwendung den Beitrag zum Redis-Speicher hinzugefügt hat
Die Konsolenausgabe zeigt an, dass die Python-Anwendung den Beitrag zum Redis-Speicher hinzugefügt hat

Du hast erfolgreich einen Beitrag in deiner lokalen Redis-Datenbank gespeichert.

Jetzt lade diesen Beitrag mit der WordPress REST API auf deine WordPress-Website hoch und speichere ihn in der standardmäßigen MariaDB– oder MySQL-Datenbank anstelle von Redis.

Einen Beitrag über die REST-API in WordPress hochladen

Die WordPress REST API bietet eine Reihe von Endpunkten, die du von deiner Anwendung aus aufrufen kannst, um mit WordPress zu interagieren. Wir verwenden den Post-Endpunkt, um einen Beitrag in WordPress zu erstellen.

Schritt 1: Lege das Anwendungskennwort in WordPress fest

Die WordPress-API erfordert ein Anwendungskennwort, damit deine Anwendung auf die Daten der WordPress-Website zugreifen kann. Das Passwort ist ein 24-stelliger geheimer Schlüssel, den du in jeder Anfrage an die REST-API angeben musst.

Erstelle ein Anwendungspasswort auf der Seite Benutzerprofil im WordPress Dashboard. Du kannst jedem Anwendungskennwort einen benutzerfreundlichen Namen zuweisen, aber du kannst das Kennwort nach der Generierung nicht mehr sehen (mach dir also eine Kopie):

Der Screenshot zeigt die Schnittstelle zum Generieren eines API-Passworts in WordPress.
Generierung eines Anwendungspassworts im WordPress Dashboard

Schritt 2: Poste mit deiner Python-Anwendung an WordPress

Installiere zunächst die Python-Request-Bibliothek, um die HTTP-Anfrage an die WordPress-API zu stellen. Führe dazu den folgenden Befehl im Terminal aus:

pip install requests

Als Nächstes erstellst du in deinem python-redis-Ordner eine neue Datei namens app.py. Öffne die Datei dann mit deinem Texteditor.

Beginne damit, die Module requests, json und base64 zu importieren:

import requests
import json
import base64

Definiere die API-Basis-URL sowie deinen WordPress-Benutzernamen und dein Passwort. Verwende für die Passwortvariable das Anwendungspasswort, das du in WordPress erstellt hast:

url = 'http://localhost/wp-json/wp/v2'
user = '<Your username here>'
password = '<Your application password here>'

Verbinde nun user und password, kodiere das Ergebnis und füge es zu den Headern der Anfrage hinzu:

creds = user + ":" + password
token = base64.b64encode(creds.encode())
header = {'Authorization': 'Basic ' + token.decode('utf-8')}

Und hier ist der Beitragstext:

post = {    
    'author': 1,
    'date': '2024-02-05 00:00:00',
    'date_gmt': '2024-02-05 00:00:00',
    'content': 'Test Post <br/><a href="http://www.my-site.com/">related blog post</a>',
    'title': 'My second post',
    'excerpt': 'In this post, I will...',
    'status': 'publish',
    'comment_status': 'open',
    'ping_status': 'open',
    'password': 'my-post-pwd',
    'slug': 'my-second-post',    
}

Richte die POST-Anfrage an die API und einen Befehl zum Drucken des Antwortstatus ein:

r = requests.post(url + '/posts', headers=header, json=post)
print(r)

Starte dein Skript mit dem folgenden Befehl im Terminal:

python app.py

Wenn du eine 201-Antwort („Created“) erhältst, bedeutet das, dass die Ressource erfolgreich hinzugefügt wurde.

Screenshot des Terminals, das einen 201-Antwortcode meldet, nachdem das Posting über Python an WordPress gesendet wurde.
Ein 201-Antwortcode wird bei einem erfolgreichen Posting zurückgegeben

Du kannst dies in deinem WordPress-Dashboard oder in der MySQL/MariaDB-Datenbank deiner Website überprüfen.

Redis-Cache direkt in WordPress verwenden

WordPress-Websites können den Redis-Cache nutzen, um Objekte wie Beiträge, Seiten oder Benutzer zwischenzuspeichern. Das Objekt kann dann bei Bedarf aus dem Cache abgerufen werden. Dieser Ansatz spart wertvolle Zeit, verringert die Latenzzeit und verbessert die Skalierbarkeit der Website und die Bewältigung von mehr Traffic.

Redis für Kinsta-Kunden

Eine schnelle Ladezeit ist für ein angenehmes Nutzererlebnis unerlässlich, und es gibt wenig Spielraum für mangelnde Leistung. Deshalb bietet Kinsta Redis als Premium Add-on an.

Wenn du das Redis-Add-on nutzen möchtest, wende dich einfach an den Kinsta-Support. Wir kümmern uns um die Installation und richten es für dich ein.

Ein Redis-Plugin installieren

Wenn du kein Kinsta-Kunde bist, musst du ein eigenes Plugin auf deiner WordPress-Seite installieren.

Installieren wir zum Beispiel das Redis Object Cache Plugin auf deiner lokalen WordPress-Website.

Screenshot: Auswahl des Redis Object Cache Plugins für die Installation in WordPress.
Das Redis Object Cache-Plugin

Öffne die Datei wp-config.php in einem Texteditor und füge den folgenden Code in den Abschnitt für benutzerdefinierte Konfigurationsvariablen ein:

define('WP_REDIS_CLIENT', 'predis');
define('WP_REDIS_HOST', 'localhost');
define('WP_REDIS_PORT', '6379');

Hinweis: Die Adresse deines Redis-Hosts hängt von deiner Serverkonfiguration ab.

Navigiere im WordPress-Dashboard zu Einstellungen > Redis. Du solltest etwas ähnliches wie das hier sehen:

Screenshot: Einstellungsseite für das Redis Object Cache Plugin in WordPress.
Das Redis Object Cache Plugin wird auf der Registerkarte Einstellungen angezeigt

Der Redis-Cache hat nun erfolgreich die vorherige MySQL-Datenbank ersetzt.

Außerdem verwendet die WordPress-Website im Frontend denselben Cache wie die Python-Anwendung im Backend. Du kannst dies testen, indem du ein neues Terminal öffnest und den folgenden Befehl ausführst:

redis-cli monitor

Während du durch deine Website navigierst, werden die Website-Anfragen in der Eingabeaufforderung ausgegeben:

Screenshot mit Redis-Server-Anfragen im Terminal.
Überwachung von Serveranfragen im Terminal mit redis-cli

Jetzt, wo Front- und Backend synchronisiert sind, kannst du mit deiner Python-Anwendung über die REST-API einen neuen Beitrag zu WordPress hinzufügen.

Ändere dazu das POST-Objekt in app.py so, dass es deinen neuen Beitrag enthält, und führe dann python app.py aus, um den Beitrag zum Cache hinzuzufügen.

Zusammenfassung

In diesem Artikel haben wir gelernt, wie man eine Redis-Datenbank mit einer Python-Anwendung über den Redis-Python-Client verbindet. Dieser Client unterstützt verschiedene Formate für Redis-Datenspeicher: Listen, Sets, Dictionaries und andere Befehlsdatentypen.

Außerdem haben wir gesehen, wie du Redis über die REST-API und das Redis Object Cache Plugin in eine WordPress-Seite integrieren kannst.

Die Möglichkeit, Redis als In-Memory-Cache für deine Website zu nutzen, macht es zu einem leistungsstarken und flexiblen Entwicklungswerkzeug. Redis ist außerordentlich effektiv, wenn es darum geht, die Geschwindigkeit deiner Datenbankabfragen, die Leistung deiner Website und die allgemeine Benutzerfreundlichkeit zu verbessern.

Ein Bonus: Kinsta kann die Installation von Redis für deine WordPress-Website übernehmen. Außerdem finden Redis-Fans ihren Lieblingsserver als eigenständige Implementierung im Managed Datenbank-Hosting Dienst von Kinsta.

Steve Bonisteel Kinsta

Steve Bonisteel is Technical Editor bij Kinsta. Hij begon zijn schrijverscarrière als verslaggever en achtervolgde ambulances en brandweerwagens. Sinds eind jaren negentig schrijft hij over internetgerelateerde technologie.