Seminar Valkey Intensivseminar: Datenmodellierung, Entwicklung und Performance

Das Intensivseminar bündelt die entwicklungsorientierten Valkey-Themen in einem vollständigen Anwendungsprojekt. Datenstrukturen, Clientintegration, Streams, Pub/Sub, Lua, Functions, Module, Search, JSON, Vektorsuche, Performance und Tests werden zu einer belastbaren Lösungsarchitektur verbunden.

Inhaltsübersicht

1. Lernziele und fachliche Einordnung
2. Anwendungsfall, Datenvertrag und Schlüsselraum
3. Datenstrukturen und Modellvarianten
4. Clientarchitektur und Verbindungsmanagement
5. Pipelining, Transaktionen und Atomarität
6. Pub/Sub, Streams und Ereignisverarbeitung
7. Lua und Functions
8. Search, JSON und Vektorsuche
9. Module und Erweiterungsarchitektur
10. Performance Engineering und Kapazität
11. Testing, Security und Produktionsfreigabe
12. Praxislabor
13. Zielgruppe, Voraussetzungen und Arbeitsweise

Lernziele

Kapitelübersicht: Ein tragfähiges Valkey-Datenmodell aus Zugriffsmustern und Lebenszyklen ableiten; Robuste Clients mit Pipelining, Resilienz, Sentinel- und Clusterunterstützung entwickeln; Echtzeit-, Event- und serverseitige Logik kontrolliert umsetzen; Search-, JSON-, Vektor- und Modulanforderungen architektonisch einordnen.

• Ein tragfähiges Valkey-Datenmodell aus Zugriffsmustern und Lebenszyklen ableiten.
• Robuste Clients mit Pipelining, Resilienz, Sentinel- und Clusterunterstützung entwickeln.
• Echtzeit-, Event- und serverseitige Logik kontrolliert umsetzen.
• Search-, JSON-, Vektor- und Modulanforderungen architektonisch einordnen.
• Performance, Sicherheit und Qualität mit automatisierten Tests absichern.

Kapitel 1: Anwendungsfall, Datenvertrag und Schlüsselraum

Kapitelübersicht: Fachliche Lese-, Schreib-, Such- und Ereignismuster vollständig erfassen; Schlüsselnamespace, Mandantentrennung, Versionierung und TTL-Regeln festlegen; Datenkritikalität, Konsistenz und Wiederherstellbarkeit als Vertrag formulieren; Messbare Akzeptanzkriterien für Funktion, Latenz, Speicher und Fehlerverhalten definieren.

• Fachliche Lese-, Schreib-, Such- und Ereignismuster vollständig erfassen.
• Schlüsselnamespace, Mandantentrennung, Versionierung und TTL-Regeln festlegen.
• Datenkritikalität, Konsistenz und Wiederherstellbarkeit als Vertrag formulieren.
• Messbare Akzeptanzkriterien für Funktion, Latenz, Speicher und Fehlerverhalten definieren.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Fachliche Lese-, Schreib-, Such- und Ereignismuster vollständig erfassen.
2. Konfiguration oder Implementierung aufbauen: Schlüsselnamespace, Mandantentrennung, Versionierung und TTL-Regeln festlegen.
3. Normal-, Grenz- und Fehlerfall prüfen: Datenkritikalität, Konsistenz und Wiederherstellbarkeit als Vertrag formulieren.
4. Betriebsentscheidung und Prüfnachweis festhalten: Messbare Akzeptanzkriterien für Funktion, Latenz, Speicher und Fehlerverhalten definieren.

Kapitel 2: Datenstrukturen und Modellvarianten

Kapitelübersicht: Strings, Hashes, Listen, Sets und Sorted Sets anhand konkreter Zugriffsmuster auswählen; Bitmaps, HyperLogLog und Geodaten für spezialisierte Anforderungen bewerten; Große, heiße und schwer löschbare Schlüssel durch Designregeln vermeiden; Modellvarianten mit Speicher- und Latenzmessungen vergleichen.

• Strings, Hashes, Listen, Sets und Sorted Sets anhand konkreter Zugriffsmuster auswählen.
• Bitmaps, HyperLogLog und Geodaten für spezialisierte Anforderungen bewerten.
• Große, heiße und schwer löschbare Schlüssel durch Designregeln vermeiden.
• Modellvarianten mit Speicher- und Latenzmessungen vergleichen.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Strings, Hashes, Listen, Sets und Sorted Sets anhand konkreter Zugriffsmuster auswählen.
2. Konfiguration oder Implementierung aufbauen: Bitmaps, HyperLogLog und Geodaten für spezialisierte Anforderungen bewerten.
3. Normal-, Grenz- und Fehlerfall prüfen: Große, heiße und schwer löschbare Schlüssel durch Designregeln vermeiden.
4. Betriebsentscheidung und Prüfnachweis festhalten: Modellvarianten mit Speicher- und Latenzmessungen vergleichen.

Kapitel 3: Clientarchitektur und Verbindungsmanagement

Kapitelübersicht: RESP-Fähigkeiten und Clientbibliotheken nach Sprache und Topologie auswählen; Pools, Timeouts, Reconnect und kontrolliertes Beenden korrekt implementieren; Fehlerklassen, Retries, Backoff, Jitter und Idempotenz zusammenführen; Clientmetriken und strukturierte Diagnoseinformationen instrumentieren.

• RESP-Fähigkeiten und Clientbibliotheken nach Sprache und Topologie auswählen.
• Pools, Timeouts, Reconnect und kontrolliertes Beenden korrekt implementieren.
• Fehlerklassen, Retries, Backoff, Jitter und Idempotenz zusammenführen.
• Clientmetriken und strukturierte Diagnoseinformationen instrumentieren.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: RESP-Fähigkeiten und Clientbibliotheken nach Sprache und Topologie auswählen.
2. Konfiguration oder Implementierung aufbauen: Pools, Timeouts, Reconnect und kontrolliertes Beenden korrekt implementieren.
3. Normal-, Grenz- und Fehlerfall prüfen: Fehlerklassen, Retries, Backoff, Jitter und Idempotenz zusammenführen.
4. Betriebsentscheidung und Prüfnachweis festhalten: Clientmetriken und strukturierte Diagnoseinformationen instrumentieren.

Kapitel 4: Pipelining, Transaktionen und Atomarität

Kapitelübersicht: Roundtrip-Kosten und Pipelinegrößen mit repräsentativer Last messen; Transaktionen und optimistische Sperren gegen Parallelzugriffe einsetzen; Serverseitige Atomarität gegen clientseitige Orchestrierung abgrenzen; Teilfehler, Timeout und Wiederholung mit automatisierten Tests absichern.

• Roundtrip-Kosten und Pipelinegrößen mit repräsentativer Last messen.
• Transaktionen und optimistische Sperren gegen Parallelzugriffe einsetzen.
• Serverseitige Atomarität gegen clientseitige Orchestrierung abgrenzen.
• Teilfehler, Timeout und Wiederholung mit automatisierten Tests absichern.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Roundtrip-Kosten und Pipelinegrößen mit repräsentativer Last messen.
2. Konfiguration oder Implementierung aufbauen: Transaktionen und optimistische Sperren gegen Parallelzugriffe einsetzen.
3. Normal-, Grenz- und Fehlerfall prüfen: Serverseitige Atomarität gegen clientseitige Orchestrierung abgrenzen.
4. Betriebsentscheidung und Prüfnachweis festhalten: Teilfehler, Timeout und Wiederholung mit automatisierten Tests absichern.

Kapitel 5: Pub/Sub, Streams und Ereignisverarbeitung

Kapitelübersicht: Flüchtige Benachrichtigung und persistente Ereignisverarbeitung fachlich trennen; Streams, Consumer Groups, Pending Entries und Acknowledgements implementieren; Wiederverarbeitung, Dead-Letter-Muster und Retention kontrollieren; Skalierung, Reihenfolge und Idempotenz in mehreren Consumers testen.

• Flüchtige Benachrichtigung und persistente Ereignisverarbeitung fachlich trennen.
• Streams, Consumer Groups, Pending Entries und Acknowledgements implementieren.
• Wiederverarbeitung, Dead-Letter-Muster und Retention kontrollieren.
• Skalierung, Reihenfolge und Idempotenz in mehreren Consumers testen.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Flüchtige Benachrichtigung und persistente Ereignisverarbeitung fachlich trennen.
2. Konfiguration oder Implementierung aufbauen: Streams, Consumer Groups, Pending Entries und Acknowledgements implementieren.
3. Normal-, Grenz- und Fehlerfall prüfen: Wiederverarbeitung, Dead-Letter-Muster und Retention kontrollieren.
4. Betriebsentscheidung und Prüfnachweis festhalten: Skalierung, Reihenfolge und Idempotenz in mehreren Consumers testen.

Kapitel 6: Lua und Functions

Kapitelübersicht: Geeignete atomare Abläufe für serverseitige Logik identifizieren; Lua-Skripte und persistente Function Libraries strukturiert entwickeln; Ausführungszeit, Schlüsselzugriffe und Fehlerverhalten sicher begrenzen; Versionierung, Deployment, Rollback und Tests in den Entwicklungsprozess integrieren.

• Geeignete atomare Abläufe für serverseitige Logik identifizieren.
• Lua-Skripte und persistente Function Libraries strukturiert entwickeln.
• Ausführungszeit, Schlüsselzugriffe und Fehlerverhalten sicher begrenzen.
• Versionierung, Deployment, Rollback und Tests in den Entwicklungsprozess integrieren.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Geeignete atomare Abläufe für serverseitige Logik identifizieren.
2. Konfiguration oder Implementierung aufbauen: Lua-Skripte und persistente Function Libraries strukturiert entwickeln.
3. Normal-, Grenz- und Fehlerfall prüfen: Ausführungszeit, Schlüsselzugriffe und Fehlerverhalten sicher begrenzen.
4. Betriebsentscheidung und Prüfnachweis festhalten: Versionierung, Deployment, Rollback und Tests in den Entwicklungsprozess integrieren.

Kapitel 7: Search, JSON und Vektorsuche

Kapitelübersicht: Dokument-, Filter-, Volltext- und Vektorsuchanforderungen voneinander abgrenzen; JSON-Dokumente, Hashes und Indexschema passend zum Abfrageprofil modellieren; Vektorindizes, Ähnlichkeitssuche und Metadatenfilter praktisch kombinieren; Indexaktualisierung, Speicher, Clusterverhalten und Relevanztests bewerten.

• Dokument-, Filter-, Volltext- und Vektorsuchanforderungen voneinander abgrenzen.
• JSON-Dokumente, Hashes und Indexschema passend zum Abfrageprofil modellieren.
• Vektorindizes, Ähnlichkeitssuche und Metadatenfilter praktisch kombinieren.
• Indexaktualisierung, Speicher, Clusterverhalten und Relevanztests bewerten.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Dokument-, Filter-, Volltext- und Vektorsuchanforderungen voneinander abgrenzen.
2. Konfiguration oder Implementierung aufbauen: JSON-Dokumente, Hashes und Indexschema passend zum Abfrageprofil modellieren.
3. Normal-, Grenz- und Fehlerfall prüfen: Vektorindizes, Ähnlichkeitssuche und Metadatenfilter praktisch kombinieren.
4. Betriebsentscheidung und Prüfnachweis festhalten: Indexaktualisierung, Speicher, Clusterverhalten und Relevanztests bewerten.

Kapitel 8: Module und Erweiterungsarchitektur

Kapitelübersicht: Standardfunktionen gegen Lua, Functions und native Module abwägen; Befehle, Datentypen, Lebenszyklus und Fehlergrenzen eines Moduls entwerfen; Threading, Blockierung, Clusterfähigkeit und Persistenz berücksichtigen; Build, Kompatibilität, Tests und sichere Auslieferung automatisieren.

• Standardfunktionen gegen Lua, Functions und native Module abwägen.
• Befehle, Datentypen, Lebenszyklus und Fehlergrenzen eines Moduls entwerfen.
• Threading, Blockierung, Clusterfähigkeit und Persistenz berücksichtigen.
• Build, Kompatibilität, Tests und sichere Auslieferung automatisieren.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Standardfunktionen gegen Lua, Functions und native Module abwägen.
2. Konfiguration oder Implementierung aufbauen: Befehle, Datentypen, Lebenszyklus und Fehlergrenzen eines Moduls entwerfen.
3. Normal-, Grenz- und Fehlerfall prüfen: Threading, Blockierung, Clusterfähigkeit und Persistenz berücksichtigen.
4. Betriebsentscheidung und Prüfnachweis festhalten: Build, Kompatibilität, Tests und sichere Auslieferung automatisieren.

Kapitel 9: Performance Engineering und Kapazität

Kapitelübersicht: Lastmodell, Datengröße, Parallelität und Serviceziele realistisch definieren; Client, Netzwerk, Datenmodell, Server und Persistenz getrennt messen; Pipelining, I/O, Speicherlayout und Schlüsselgröße zielgerichtet optimieren; Kapazitätsgrenzen, Überlastschutz und Skalierungsentscheidung dokumentieren.

• Lastmodell, Datengröße, Parallelität und Serviceziele realistisch definieren.
• Client, Netzwerk, Datenmodell, Server und Persistenz getrennt messen.
• Pipelining, I/O, Speicherlayout und Schlüsselgröße zielgerichtet optimieren.
• Kapazitätsgrenzen, Überlastschutz und Skalierungsentscheidung dokumentieren.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Lastmodell, Datengröße, Parallelität und Serviceziele realistisch definieren.
2. Konfiguration oder Implementierung aufbauen: Client, Netzwerk, Datenmodell, Server und Persistenz getrennt messen.
3. Normal-, Grenz- und Fehlerfall prüfen: Pipelining, I/O, Speicherlayout und Schlüsselgröße zielgerichtet optimieren.
4. Betriebsentscheidung und Prüfnachweis festhalten: Kapazitätsgrenzen, Überlastschutz und Skalierungsentscheidung dokumentieren.

Kapitel 10: Testing, Security und Produktionsfreigabe

Kapitelübersicht: Unit-, Integrations-, Kompatibilitäts-, Last- und Failovertests staffeln; ACL, TLS, Geheimnisrotation und minimale Rechte in die Anwendung integrieren; Fehler-, Wiederholungs- und Topologieänderungsszenarien automatisiert prüfen; Produktionsfreigabe mit Datenvertrag, Metriken, Runbooks und Abnahmekriterien durchführen.

• Unit-, Integrations-, Kompatibilitäts-, Last- und Failovertests staffeln.
• ACL, TLS, Geheimnisrotation und minimale Rechte in die Anwendung integrieren.
• Fehler-, Wiederholungs- und Topologieänderungsszenarien automatisiert prüfen.
• Produktionsfreigabe mit Datenvertrag, Metriken, Runbooks und Abnahmekriterien durchführen.

Schritt-für-Schritt-Praxis

1. Ausgangslage und Zielkriterien erfassen: Unit-, Integrations-, Kompatibilitäts-, Last- und Failovertests staffeln.
2. Konfiguration oder Implementierung aufbauen: ACL, TLS, Geheimnisrotation und minimale Rechte in die Anwendung integrieren.
3. Normal-, Grenz- und Fehlerfall prüfen: Fehler-, Wiederholungs- und Topologieänderungsszenarien automatisiert prüfen.
4. Betriebsentscheidung und Prüfnachweis festhalten: Produktionsfreigabe mit Datenvertrag, Metriken, Runbooks und Abnahmekriterien durchführen.

Praxislabor

Kapitelübersicht: Ein vollständiges Datenmodell mit TTLs, Streams und Suchindex für eine Beispielanwendung entwerfen; Eine robuste Clientintegration mit Pooling, Pipelining, Retries und Telemetrie implementieren; Eine atomare Function Library und einen ereignisbasierten Consumer mit Wiederverarbeitung entwickeln; Search-, JSON- und Vektorabfragen aufbauen und unter repräsentativer Last messen; Das Gesamtprojekt mit ACL, TLS, Tests, Failoverprüfung und Produktionscheckliste abnehmen.

1. Ein vollständiges Datenmodell mit TTLs, Streams und Suchindex für eine Beispielanwendung entwerfen.
2. Eine robuste Clientintegration mit Pooling, Pipelining, Retries und Telemetrie implementieren.
3. Eine atomare Function Library und einen ereignisbasierten Consumer mit Wiederverarbeitung entwickeln.
4. Search-, JSON- und Vektorabfragen aufbauen und unter repräsentativer Last messen.
5. Das Gesamtprojekt mit ACL, TLS, Tests, Failoverprüfung und Produktionscheckliste abnehmen.

Zielgruppe, Voraussetzungen und Arbeitsweise

Kapitelübersicht: Zielgruppe: Senior-Entwicklung, Software- und Datenarchitektur, Integration Engineering, Performance Engineering, DevOps und technische Qualitätssicherung; Voraussetzungen: Sichere Programmierkenntnisse, Valkey-Grundlagen und Erfahrung mit verteilten Anwendungen, Tests und Kommandozeilenwerkzeugen; Arbeitsweise: Fachvortrag, Demonstrationen, angeleitete Laboraufgaben, Fehleranalysen und dokumentierte Abnahmen.

Zielgruppe: Senior-Entwicklung, Software- und Datenarchitektur, Integration Engineering, Performance Engineering, DevOps und technische Qualitätssicherung.

Voraussetzungen: Sichere Programmierkenntnisse, Valkey-Grundlagen und Erfahrung mit verteilten Anwendungen, Tests und Kommandozeilenwerkzeugen.

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