Seminar Valkey Serverseitige Logik mit Lua und Functions

Serverseitige Logik reduziert Netzwerkrunden und kann mehrere Änderungen atomar verbinden. Gleichzeitig erhöht sie das Risiko langer Laufzeiten, schwerer Fehleranalyse und unkontrollierter Abhängigkeiten. Das Seminar vermittelt einen disziplinierten Einsatz von Lua-Skripten und Valkey Functions mit Tests, Versionierung und Betriebsgrenzen.

Inhaltsübersicht

1. Lernziele und fachliche Einordnung
2. Entscheidungsrahmen für serverseitige Logik
3. Lua-Grundlagen im Valkey-Kontext
4. Atomare Skripte und Schlüsselzugriffe
5. Functions und Bibliotheksverwaltung
6. Replikation, Persistenz und Cluster
7. Performance, Debugging und Schutzgrenzen
8. Tests, Deployment und Wartung
9. Praxislabor
10. Zielgruppe, Voraussetzungen und Arbeitsweise

Lernziele

Kapitelübersicht: Lua, Functions, Transaktionen und Clientlogik nach geeigneten Einsatzfällen abgrenzen; Atomare Skripte mit expliziten Schlüsseln und sicherer Fehlerbehandlung entwickeln; Functions und Bibliotheken versioniert laden, aufrufen und aktualisieren; Replikations-, Persistenz-, Cluster- und Performancewirkungen berücksichtigen.

• Lua, Functions, Transaktionen und Clientlogik nach geeigneten Einsatzfällen abgrenzen.
• Atomare Skripte mit expliziten Schlüsseln und sicherer Fehlerbehandlung entwickeln.
• Functions und Bibliotheken versioniert laden, aufrufen und aktualisieren.
• Replikations-, Persistenz-, Cluster- und Performancewirkungen berücksichtigen.
• Serverseitige Logik mit Tests, Monitoring, Rollout und Rollback produktionsfähig betreiben.

Kapitel 1: Entscheidungsrahmen für serverseitige Logik

Kapitelübersicht: Netzwerkrunden, Atomarität und Datenlokalität als Nutzenkriterien bewerten; Lua, Functions, Transaktionen, Pipelining und Module klar voneinander abgrenzen; Maximale Laufzeit, Datenmenge und Fehlerwirkung vor der Implementierung begrenzen; Verantwortung, Versionsstrategie und Rückbauoption festlegen.

• Netzwerkrunden, Atomarität und Datenlokalität als Nutzenkriterien bewerten.
• Lua, Functions, Transaktionen, Pipelining und Module klar voneinander abgrenzen.
• Maximale Laufzeit, Datenmenge und Fehlerwirkung vor der Implementierung begrenzen.
• Verantwortung, Versionsstrategie und Rückbauoption festlegen.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Netzwerkrunden, Atomarität und Datenlokalität als Nutzenkriterien bewerten.
2. Konfiguration oder Implementierung aufbauen: Lua, Functions, Transaktionen, Pipelining und Module klar voneinander abgrenzen.
3. Normal-, Grenz- und Fehlerfall prüfen: Maximale Laufzeit, Datenmenge und Fehlerwirkung vor der Implementierung begrenzen.
4. Betriebsentscheidung und Prüfnachweis festhalten: Verantwortung, Versionsstrategie und Rückbauoption festlegen.

Kapitel 2: Lua-Grundlagen im Valkey-Kontext

Kapitelübersicht: Datentypen, Tabellen, Bedingungen, Schleifen und Fehlerbehandlung zielgerichtet anwenden; Argumente und Schlüssel über definierte Schnittstellen übergeben; Valkey-Befehle aus Lua aufrufen und Rückgabewerte korrekt konvertieren; Determinismus und verbotene Nebenwirkungen im Serverkontext berücksichtigen.

• Datentypen, Tabellen, Bedingungen, Schleifen und Fehlerbehandlung zielgerichtet anwenden.
• Argumente und Schlüssel über definierte Schnittstellen übergeben.
• Valkey-Befehle aus Lua aufrufen und Rückgabewerte korrekt konvertieren.
• Determinismus und verbotene Nebenwirkungen im Serverkontext berücksichtigen.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Datentypen, Tabellen, Bedingungen, Schleifen und Fehlerbehandlung zielgerichtet anwenden.
2. Konfiguration oder Implementierung aufbauen: Argumente und Schlüssel über definierte Schnittstellen übergeben.
3. Normal-, Grenz- und Fehlerfall prüfen: Valkey-Befehle aus Lua aufrufen und Rückgabewerte korrekt konvertieren.
4. Betriebsentscheidung und Prüfnachweis festhalten: Determinismus und verbotene Nebenwirkungen im Serverkontext berücksichtigen.

Kapitel 3: Atomare Skripte und Schlüsselzugriffe

Kapitelübersicht: Lese- und Schreibfolge als atomaren Ablauf entwerfen; Schlüssel explizit deklarieren und dynamische unprüfbare Zugriffe vermeiden; Vorbedingungen, Grenzwerte und fachliche Fehler sauber zurückgeben; Teiländerungen und unklare Wiederholbarkeit durch idempotente Regeln verhindern.

• Lese- und Schreibfolge als atomaren Ablauf entwerfen.
• Schlüssel explizit deklarieren und dynamische unprüfbare Zugriffe vermeiden.
• Vorbedingungen, Grenzwerte und fachliche Fehler sauber zurückgeben.
• Teiländerungen und unklare Wiederholbarkeit durch idempotente Regeln verhindern.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Lese- und Schreibfolge als atomaren Ablauf entwerfen.
2. Konfiguration oder Implementierung aufbauen: Schlüssel explizit deklarieren und dynamische unprüfbare Zugriffe vermeiden.
3. Normal-, Grenz- und Fehlerfall prüfen: Vorbedingungen, Grenzwerte und fachliche Fehler sauber zurückgeben.
4. Betriebsentscheidung und Prüfnachweis festhalten: Teiländerungen und unklare Wiederholbarkeit durch idempotente Regeln verhindern.

Kapitel 4: Functions und Bibliotheksverwaltung

Kapitelübersicht: Bibliothek, Funktionsnamen und registrierte Einstiegspunkte strukturieren; Functions laden, auflisten, aufrufen und kontrolliert ersetzen; Kompatibilität zwischen Versionen und parallele Einführung planen; Eigentümer, Dokumentation und Freigabeprozess für Bibliotheken festlegen.

• Bibliothek, Funktionsnamen und registrierte Einstiegspunkte strukturieren.
• Functions laden, auflisten, aufrufen und kontrolliert ersetzen.
• Kompatibilität zwischen Versionen und parallele Einführung planen.
• Eigentümer, Dokumentation und Freigabeprozess für Bibliotheken festlegen.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Bibliothek, Funktionsnamen und registrierte Einstiegspunkte strukturieren.
2. Konfiguration oder Implementierung aufbauen: Functions laden, auflisten, aufrufen und kontrolliert ersetzen.
3. Normal-, Grenz- und Fehlerfall prüfen: Kompatibilität zwischen Versionen und parallele Einführung planen.
4. Betriebsentscheidung und Prüfnachweis festhalten: Eigentümer, Dokumentation und Freigabeprozess für Bibliotheken festlegen.

Kapitel 5: Replikation, Persistenz und Cluster

Kapitelübersicht: Ausführung und resultierende Änderungen im Replikationspfad nachvollziehen; Wiederanlauf und Funktionsverfügbarkeit nach Restore oder Knotenwechsel prüfen; Schlüsselplatzierung und Cross-Slot-Grenzen in Clusterumgebungen berücksichtigen; Rollout auf alle erforderlichen Knoten konsistent automatisieren.

• Ausführung und resultierende Änderungen im Replikationspfad nachvollziehen.
• Wiederanlauf und Funktionsverfügbarkeit nach Restore oder Knotenwechsel prüfen.
• Schlüsselplatzierung und Cross-Slot-Grenzen in Clusterumgebungen berücksichtigen.
• Rollout auf alle erforderlichen Knoten konsistent automatisieren.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Ausführung und resultierende Änderungen im Replikationspfad nachvollziehen.
2. Konfiguration oder Implementierung aufbauen: Wiederanlauf und Funktionsverfügbarkeit nach Restore oder Knotenwechsel prüfen.
3. Normal-, Grenz- und Fehlerfall prüfen: Schlüsselplatzierung und Cross-Slot-Grenzen in Clusterumgebungen berücksichtigen.
4. Betriebsentscheidung und Prüfnachweis festhalten: Rollout auf alle erforderlichen Knoten konsistent automatisieren.

Kapitel 6: Performance, Debugging und Schutzgrenzen

Kapitelübersicht: Laufzeit und Befehlsanzahl mit realistischen Datengrößen messen; Lange oder blockierende Skripte erkennen und durch kleinere Operationen ersetzen; Fehler mit Testdaten, Rückgabecodes und protokollierten Kontextwerten reproduzieren; Watchdog-, Abbruch- und Incident-Verfahren für problematische Ausführung festlegen.

• Laufzeit und Befehlsanzahl mit realistischen Datengrößen messen.
• Lange oder blockierende Skripte erkennen und durch kleinere Operationen ersetzen.
• Fehler mit Testdaten, Rückgabecodes und protokollierten Kontextwerten reproduzieren.
• Watchdog-, Abbruch- und Incident-Verfahren für problematische Ausführung festlegen.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Laufzeit und Befehlsanzahl mit realistischen Datengrößen messen.
2. Konfiguration oder Implementierung aufbauen: Lange oder blockierende Skripte erkennen und durch kleinere Operationen ersetzen.
3. Normal-, Grenz- und Fehlerfall prüfen: Fehler mit Testdaten, Rückgabecodes und protokollierten Kontextwerten reproduzieren.
4. Betriebsentscheidung und Prüfnachweis festhalten: Watchdog-, Abbruch- und Incident-Verfahren für problematische Ausführung festlegen.

Kapitel 7: Tests, Deployment und Wartung

Kapitelübersicht: Unit- und Integrationsfälle für Normal-, Grenz- und Wiederholungsfälle erstellen; ACL-Rechte für Funktionsaufruf und verwendete Befehle minimal halten; Stufenweisen Rollout, Kompatibilitätsfenster und Rollback automatisieren; Inventar, Metriken, Änderungsnachweis und regelmäßige Überprüfung pflegen.

• Unit- und Integrationsfälle für Normal-, Grenz- und Wiederholungsfälle erstellen.
• ACL-Rechte für Funktionsaufruf und verwendete Befehle minimal halten.
• Stufenweisen Rollout, Kompatibilitätsfenster und Rollback automatisieren.
• Inventar, Metriken, Änderungsnachweis und regelmäßige Überprüfung pflegen.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Unit- und Integrationsfälle für Normal-, Grenz- und Wiederholungsfälle erstellen.
2. Konfiguration oder Implementierung aufbauen: ACL-Rechte für Funktionsaufruf und verwendete Befehle minimal halten.
3. Normal-, Grenz- und Fehlerfall prüfen: Stufenweisen Rollout, Kompatibilitätsfenster und Rollback automatisieren.
4. Betriebsentscheidung und Prüfnachweis festhalten: Inventar, Metriken, Änderungsnachweis und regelmäßige Überprüfung pflegen.

Praxislabor

Kapitelübersicht: Ein atomisches Lua-Skript mit expliziten Schlüsseln, Validierung und Fehlercodes entwickeln; Eine Function-Bibliothek laden, versionieren und mit kontrollierter Schnittstelle aufrufen; Cluster-, ACL- und Wiederholungsfälle automatisiert testen; Laufzeitprobleme diagnostizieren und ein sicheres Rollout- und Rollbackverfahren dokumentieren.

1. Ein atomisches Lua-Skript mit expliziten Schlüsseln, Validierung und Fehlercodes entwickeln.
2. Eine Function-Bibliothek laden, versionieren und mit kontrollierter Schnittstelle aufrufen.
3. Cluster-, ACL- und Wiederholungsfälle automatisiert testen.
4. Laufzeitprobleme diagnostizieren und ein sicheres Rollout- und Rollbackverfahren dokumentieren.

Zielgruppe, Voraussetzungen und Arbeitsweise

Kapitelübersicht: Zielgruppe: Softwareentwicklung, Integrationsentwicklung, Plattformengineering, DevOps und technische Architektur; Voraussetzungen: Gute Valkey-Grundkenntnisse und sichere Programmiererfahrung; Lua-Vorkenntnisse sind hilfreich, aber nicht erforderlich; Arbeitsweise: Fachvortrag, Demonstrationen, angeleitete Laboraufgaben, Fehleranalysen und dokumentierte Abnahmen.

Zielgruppe: Softwareentwicklung, Integrationsentwicklung, Plattformengineering, DevOps und technische Architektur.

Voraussetzungen: Gute Valkey-Grundkenntnisse und sichere Programmiererfahrung; Lua-Vorkenntnisse sind hilfreich, aber nicht erforderlich.

Arbeitsweise: Fachvortrag, technische Demonstrationen, strukturierte Schrittfolgen, praktische Übungen am System, kontrollierte Fehlerfälle und schriftliche Prüfpunkte.