Seminar Valkey Module und Erweiterungsentwicklung

Module erweitern Valkey um eigene Befehle, Datentypen und servernahe Funktionen. Damit steigt zugleich die Verantwortung für Speicherverwaltung, Replikation, Persistenz, Clusterverhalten, Sicherheit und Binärkompatibilität. Das Seminar führt durch den vollständigen Entwicklungszyklus einer produktionsfähigen Erweiterung.

Inhaltsübersicht

1. Lernziele und fachliche Einordnung
2. Entscheidungsrahmen und Modularchitektur
3. Build-Umgebung und Lebenszyklus
4. Befehle, Argumente und Schlüsselzugriffe
5. Eigene Datentypen und Speicherverwaltung
6. Persistenz, Replikation und AOF
7. Nebenläufigkeit, Blockierung und Ereignisse
8. Cluster- und Sicherheitsverträglichkeit
9. Tests, Qualität und Performance
10. Paketierung, Rollout und Wartung
11. Praxislabor
12. Zielgruppe, Voraussetzungen und Arbeitsweise

Lernziele

Kapitelübersicht: Geeignete Anwendungsfälle für Module gegenüber Standardbefehlen, Lua und Functions abgrenzen; Ein Modul mit eigenem Befehl, Argumentprüfung und sauberer Fehlerbehandlung implementieren; Speicher-, Threading-, Persistenz-, Replikations- und Clusteranforderungen berücksichtigen; Automatisierte Funktions-, Fehlersicherheits- und Performancetests aufbauen.

• Geeignete Anwendungsfälle für Module gegenüber Standardbefehlen, Lua und Functions abgrenzen.
• Ein Modul mit eigenem Befehl, Argumentprüfung und sauberer Fehlerbehandlung implementieren.
• Speicher-, Threading-, Persistenz-, Replikations- und Clusteranforderungen berücksichtigen.
• Automatisierte Funktions-, Fehlersicherheits- und Performancetests aufbauen.
• Pakete, Versionierung, Rollout, Upgrade und Support für den produktiven Einsatz planen.

Kapitel 1: Entscheidungsrahmen und Modularchitektur

Kapitelübersicht: Standardbefehle, Datenmodellierung, Lua, Functions und Module nach Eingriffstiefe vergleichen; Latenz-, Speicher-, Sicherheits- und Betriebsfolgen einer Servererweiterung bewerten; Befehle, Datentypen, Hooks und Hintergrundarbeit als Modulbausteine einordnen; Akzeptanzkriterien und Rückbauoption vor Beginn der Implementierung definieren.

• Standardbefehle, Datenmodellierung, Lua, Functions und Module nach Eingriffstiefe vergleichen.
• Latenz-, Speicher-, Sicherheits- und Betriebsfolgen einer Servererweiterung bewerten.
• Befehle, Datentypen, Hooks und Hintergrundarbeit als Modulbausteine einordnen.
• Akzeptanzkriterien und Rückbauoption vor Beginn der Implementierung definieren.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Standardbefehle, Datenmodellierung, Lua, Functions und Module nach Eingriffstiefe vergleichen.
2. Konfiguration oder Implementierung aufbauen: Latenz-, Speicher-, Sicherheits- und Betriebsfolgen einer Servererweiterung bewerten.
3. Normal-, Grenz- und Fehlerfall prüfen: Befehle, Datentypen, Hooks und Hintergrundarbeit als Modulbausteine einordnen.
4. Betriebsentscheidung und Prüfnachweis festhalten: Akzeptanzkriterien und Rückbauoption vor Beginn der Implementierung definieren.

Kapitel 2: Build-Umgebung und Lebenszyklus

Kapitelübersicht: Compiler, Header, Buildsystem und reproduzierbare Artefakterzeugung einrichten; Lade-, Initialisierungs- und Entladeverhalten eines Minimalmoduls nachvollziehen; Versionsinformationen, Konfigurationsparameter und Diagnoseausgaben bereitstellen; Fehlschläge beim Laden ohne Beeinträchtigung des Servers behandeln.

• Compiler, Header, Buildsystem und reproduzierbare Artefakterzeugung einrichten.
• Lade-, Initialisierungs- und Entladeverhalten eines Minimalmoduls nachvollziehen.
• Versionsinformationen, Konfigurationsparameter und Diagnoseausgaben bereitstellen.
• Fehlschläge beim Laden ohne Beeinträchtigung des Servers behandeln.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Compiler, Header, Buildsystem und reproduzierbare Artefakterzeugung einrichten.
2. Konfiguration oder Implementierung aufbauen: Lade-, Initialisierungs- und Entladeverhalten eines Minimalmoduls nachvollziehen.
3. Normal-, Grenz- und Fehlerfall prüfen: Versionsinformationen, Konfigurationsparameter und Diagnoseausgaben bereitstellen.
4. Betriebsentscheidung und Prüfnachweis festhalten: Fehlschläge beim Laden ohne Beeinträchtigung des Servers behandeln.

Kapitel 3: Befehle, Argumente und Schlüsselzugriffe

Kapitelübersicht: Eigene Befehle mit klarer Syntax, Arity und aussagekräftigen Fehlern registrieren; Argumente sicher parsen und Grenzwerte vor Ressourcenverbrauch prüfen; Schlüssel mit korrekten Zugriffsmodi öffnen, lesen, ändern und schließen; Befehlsflags, ACL-Kategorien und Schlüsselermittlung für Clients und Cluster pflegen.

• Eigene Befehle mit klarer Syntax, Arity und aussagekräftigen Fehlern registrieren.
• Argumente sicher parsen und Grenzwerte vor Ressourcenverbrauch prüfen.
• Schlüssel mit korrekten Zugriffsmodi öffnen, lesen, ändern und schließen.
• Befehlsflags, ACL-Kategorien und Schlüsselermittlung für Clients und Cluster pflegen.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Eigene Befehle mit klarer Syntax, Arity und aussagekräftigen Fehlern registrieren.
2. Konfiguration oder Implementierung aufbauen: Argumente sicher parsen und Grenzwerte vor Ressourcenverbrauch prüfen.
3. Normal-, Grenz- und Fehlerfall prüfen: Schlüssel mit korrekten Zugriffsmodi öffnen, lesen, ändern und schließen.
4. Betriebsentscheidung und Prüfnachweis festhalten: Befehlsflags, ACL-Kategorien und Schlüsselermittlung für Clients und Cluster pflegen.

Kapitel 4: Eigene Datentypen und Speicherverwaltung

Kapitelübersicht: Interne Datenstruktur mit eindeutigem Eigentum und Lebenszyklus entwerfen; Allokation, Freigabe, Kopieren und Defragmentierungsanforderungen kontrollieren; Speicherverbrauch und Grenzfälle bei großen oder häufig mutierten Objekten messen; Informations- und Diagnosefunktionen für den Betrieb ergänzen.

• Interne Datenstruktur mit eindeutigem Eigentum und Lebenszyklus entwerfen.
• Allokation, Freigabe, Kopieren und Defragmentierungsanforderungen kontrollieren.
• Speicherverbrauch und Grenzfälle bei großen oder häufig mutierten Objekten messen.
• Informations- und Diagnosefunktionen für den Betrieb ergänzen.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Interne Datenstruktur mit eindeutigem Eigentum und Lebenszyklus entwerfen.
2. Konfiguration oder Implementierung aufbauen: Allokation, Freigabe, Kopieren und Defragmentierungsanforderungen kontrollieren.
3. Normal-, Grenz- und Fehlerfall prüfen: Speicherverbrauch und Grenzfälle bei großen oder häufig mutierten Objekten messen.
4. Betriebsentscheidung und Prüfnachweis festhalten: Informations- und Diagnosefunktionen für den Betrieb ergänzen.

Kapitel 5: Persistenz, Replikation und AOF

Kapitelübersicht: RDB-Serialisierung und -Deserialisierung versionssicher implementieren; AOF-Rewrite und reproduzierbare Befehlsdarstellung für Änderungen festlegen; Replikationswirkung eigener Befehle und deterministisches Verhalten prüfen; Ladefehler, alte Datenformate und Upgradepfade ohne stillen Datenverlust behandeln.

• RDB-Serialisierung und -Deserialisierung versionssicher implementieren.
• AOF-Rewrite und reproduzierbare Befehlsdarstellung für Änderungen festlegen.
• Replikationswirkung eigener Befehle und deterministisches Verhalten prüfen.
• Ladefehler, alte Datenformate und Upgradepfade ohne stillen Datenverlust behandeln.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: RDB-Serialisierung und -Deserialisierung versionssicher implementieren.
2. Konfiguration oder Implementierung aufbauen: AOF-Rewrite und reproduzierbare Befehlsdarstellung für Änderungen festlegen.
3. Normal-, Grenz- und Fehlerfall prüfen: Replikationswirkung eigener Befehle und deterministisches Verhalten prüfen.
4. Betriebsentscheidung und Prüfnachweis festhalten: Ladefehler, alte Datenformate und Upgradepfade ohne stillen Datenverlust behandeln.

Kapitel 6: Nebenläufigkeit, Blockierung und Ereignisse

Kapitelübersicht: Serverthread, Thread-Safe Context und blockierende Arbeit korrekt abgrenzen; Lange Berechnungen aus dem Hauptpfad herauslösen und Ergebnisse sicher zurückführen; Timer, Keyspace-Ereignisse und Serverereignisse ohne Reentrancy-Fehler verwenden; Abbruch, Clienttrennung und Shutdown in allen Zuständen sauber behandeln.

• Serverthread, Thread-Safe Context und blockierende Arbeit korrekt abgrenzen.
• Lange Berechnungen aus dem Hauptpfad herauslösen und Ergebnisse sicher zurückführen.
• Timer, Keyspace-Ereignisse und Serverereignisse ohne Reentrancy-Fehler verwenden.
• Abbruch, Clienttrennung und Shutdown in allen Zuständen sauber behandeln.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Serverthread, Thread-Safe Context und blockierende Arbeit korrekt abgrenzen.
2. Konfiguration oder Implementierung aufbauen: Lange Berechnungen aus dem Hauptpfad herauslösen und Ergebnisse sicher zurückführen.
3. Normal-, Grenz- und Fehlerfall prüfen: Timer, Keyspace-Ereignisse und Serverereignisse ohne Reentrancy-Fehler verwenden.
4. Betriebsentscheidung und Prüfnachweis festhalten: Abbruch, Clienttrennung und Shutdown in allen Zuständen sauber behandeln.

Kapitel 7: Cluster- und Sicherheitsverträglichkeit

Kapitelübersicht: Schlüsseldeklaration und Hash-Tags für clusterfähige Befehle prüfen; Cross-Slot-Aufrufe, Weiterleitungen und Resharding-Situationen kontrolliert behandeln; Eingabedaten, Ressourcengrenzen, Dateizugriffe und privilegierte Funktionen härten; Bedrohungsmodell, Minimalrechte und sichere Standardkonfiguration dokumentieren.

• Schlüsseldeklaration und Hash-Tags für clusterfähige Befehle prüfen.
• Cross-Slot-Aufrufe, Weiterleitungen und Resharding-Situationen kontrolliert behandeln.
• Eingabedaten, Ressourcengrenzen, Dateizugriffe und privilegierte Funktionen härten.
• Bedrohungsmodell, Minimalrechte und sichere Standardkonfiguration dokumentieren.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Schlüsseldeklaration und Hash-Tags für clusterfähige Befehle prüfen.
2. Konfiguration oder Implementierung aufbauen: Cross-Slot-Aufrufe, Weiterleitungen und Resharding-Situationen kontrolliert behandeln.
3. Normal-, Grenz- und Fehlerfall prüfen: Eingabedaten, Ressourcengrenzen, Dateizugriffe und privilegierte Funktionen härten.
4. Betriebsentscheidung und Prüfnachweis festhalten: Bedrohungsmodell, Minimalrechte und sichere Standardkonfiguration dokumentieren.

Kapitel 8: Tests, Qualität und Performance

Kapitelübersicht: Unit-, Integrations-, Persistenz- und Replikationstests automatisieren; Fehlerfälle, beschädigte Daten, Speicherknappheit und ungeplante Abbrüche simulieren; Fuzzing, Sanitizer und Speicherprüfungen in die Build-Pipeline aufnehmen; Latenz, Durchsatz und Speicherbedarf gegen eine definierte Baseline bewerten.

• Unit-, Integrations-, Persistenz- und Replikationstests automatisieren.
• Fehlerfälle, beschädigte Daten, Speicherknappheit und ungeplante Abbrüche simulieren.
• Fuzzing, Sanitizer und Speicherprüfungen in die Build-Pipeline aufnehmen.
• Latenz, Durchsatz und Speicherbedarf gegen eine definierte Baseline bewerten.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Unit-, Integrations-, Persistenz- und Replikationstests automatisieren.
2. Konfiguration oder Implementierung aufbauen: Fehlerfälle, beschädigte Daten, Speicherknappheit und ungeplante Abbrüche simulieren.
3. Normal-, Grenz- und Fehlerfall prüfen: Fuzzing, Sanitizer und Speicherprüfungen in die Build-Pipeline aufnehmen.
4. Betriebsentscheidung und Prüfnachweis festhalten: Latenz, Durchsatz und Speicherbedarf gegen eine definierte Baseline bewerten.

Kapitel 9: Paketierung, Rollout und Wartung

Kapitelübersicht: Artefakte für Zielplattformen signieren, versionieren und nachvollziehbar verteilen; Kompatibilitätsmatrix für Valkey-Version, Betriebssystem und Architektur pflegen; Rolling Rollout, Rückbau und Datenformatmigration als Betriebsablauf testen; Supportgrenzen, Monitoring, Release Notes und Sicherheitsupdates festlegen.

• Artefakte für Zielplattformen signieren, versionieren und nachvollziehbar verteilen.
• Kompatibilitätsmatrix für Valkey-Version, Betriebssystem und Architektur pflegen.
• Rolling Rollout, Rückbau und Datenformatmigration als Betriebsablauf testen.
• Supportgrenzen, Monitoring, Release Notes und Sicherheitsupdates festlegen.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Artefakte für Zielplattformen signieren, versionieren und nachvollziehbar verteilen.
2. Konfiguration oder Implementierung aufbauen: Kompatibilitätsmatrix für Valkey-Version, Betriebssystem und Architektur pflegen.
3. Normal-, Grenz- und Fehlerfall prüfen: Rolling Rollout, Rückbau und Datenformatmigration als Betriebsablauf testen.
4. Betriebsentscheidung und Prüfnachweis festhalten: Supportgrenzen, Monitoring, Release Notes und Sicherheitsupdates festlegen.

Praxislabor

Kapitelübersicht: Ein Minimalmodul bauen, laden und mit einem eigenen Befehl erweitern; Einen kleinen eigenen Datentyp mit Speicherverwaltung und Diagnosefunktion implementieren; RDB-, AOF- und Replikationsverhalten des Moduls automatisiert testen; Clusterfähigkeit, Ressourcengrenzen, Fehlersicherheit und Performance in einer Abnahmeprüfung bewerten.

1. Ein Minimalmodul bauen, laden und mit einem eigenen Befehl erweitern.
2. Einen kleinen eigenen Datentyp mit Speicherverwaltung und Diagnosefunktion implementieren.
3. RDB-, AOF- und Replikationsverhalten des Moduls automatisiert testen.
4. Clusterfähigkeit, Ressourcengrenzen, Fehlersicherheit und Performance in einer Abnahmeprüfung bewerten.

Zielgruppe, Voraussetzungen und Arbeitsweise

Kapitelübersicht: Zielgruppe: C- und Systementwickler, Plattformengineering, Performance Engineering, Security Engineering und technische Architektur; Voraussetzungen: Sichere C-Kenntnisse, Erfahrung mit Speicherverwaltung, Buildsystemen und Debugging sowie fundierte Valkey-Grundkenntnisse; Arbeitsweise: Fachvortrag, Demonstrationen, angeleitete Laboraufgaben, Fehleranalysen und dokumentierte Abnahmen.

Zielgruppe: C- und Systementwickler, Plattformengineering, Performance Engineering, Security Engineering und technische Architektur.

Voraussetzungen: Sichere C-Kenntnisse, Erfahrung mit Speicherverwaltung, Buildsystemen und Debugging sowie fundierte Valkey-Grundkenntnisse.

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