Echtzeit-Workout-Ranglisten mit Node.js und PostgreSQL

In der wettbewerbsintensiven Welt von Fitness-Apps ist Echtzeit-Feedback der König. Eine Live-Bestenliste mit Workout-Rankings kann das Nutzerengagement drastisch steigern und die Nutzer motivieren, ihre Grenzen zu überschreiten. Der Aufbau einer Bestenliste, die sowohl Echtzeit-als auch skalierbar ist, stellt jedoch eine erhebliche technische Herausforderung dar. Das naive Abfragen der Hauptdatenbank nach Ranglisten alle paar Sekunden kann zu Leistungsengpässen und einer trägen Nutzererfahrung führen, insbesondere wenn die Nutzerbasis wächst.

Dieses Tutorial führt Sie durch den Aufbau einer leistungsorientierten, Echtzeit-Workout-Bestenliste unter Verwendung einer leistungsstarken Kombination von Technologien. Wir speichern unsere Kerndaten in PostgreSQL, einer robusten und zuverlässigen relationalen Datenbank. Für blitzschnelle Rankings und Score-Updates verwenden wir Redis als Caching-Schicht. Schließlich nutzen wir Node.js und Socket.IO, um Live-Updates an den Client zu pushen und sicherzustellen, dass die Bestenliste immer aktuell ist.

Am Ende dieses Leitfadens werden Sie ein solides Verständnis dafür haben, wie man ein effizientes, skalierbares und produktionsreifes Echtzeit-System entwirft.

Voraussetzungen:

• Grundlegendes Verständnis von Node.js und Express.
• Vertrautheit mit JavaScript (ES6+).

• Docker auf Ihrem Rechner installiert (für einfaches Ausführen von PostgreSQL und Redis).

• Node.js und npm (oder yarn) installiert.

Das Problem verstehen

Eine Echtzeit-Bestenliste muss zwei Dinge außergewöhnlich gut können: ein hohes Volumen an Score-Updates verarbeiten und Rankings sofort an viele gleichzeitige Nutzer liefern.

Die Herausforderung:

• Datenbankbelastung: Das ständige Neuberechnen von Rängen mit SQL-Abfragen, die große Datensätze sortieren (ORDER BY score DESC), ist rechenintensiv und belastet die primäre Datenbank stark.
• Latenz: Nutzer erwarten sofortige Updates. Die Zeit, die das Schreiben in die Datenbank, das Neuberechnen der Bestenliste und das erneute Abrufen der Daten durch den Client dauert, kann zu spürbarer Verzögerung führen.

Unser Ansatz: Das „Cache-Aside"-Muster

Um dies zu lösen, verwenden wir das „Cache-Aside"-Muster. Der Ablauf ist wie folgt:

1. Write-through: Neue Workout-Scores werden in unsere primäre Datenbank (PostgreSQL) geschrieben, um Persistenz zu gewährleisten.
2. Cache-Update: Gleichzeitig aktualisieren wir den Score des Nutzers in einem Redis Sorted Set. Redis ist ein In-Memory-Datenspeicher, wodurch Operationen wie Sortieren und Ranking unglaublich schnell sind.
3. Echtzeit-Push: Nach dem Update sendet unser Node.js-Server ein „Bestenliste aktualisiert"-Event über WebSockets (Socket.IO) an alle verbundenen Clients.
4. Client-Update: Die Clients empfangen dieses Event und aktualisieren die Bestenlisten-Anzeige in Echtzeit, ohne eine weitere HTTP-Anfrage senden zu müssen.

Diese Architektur stellt sicher, dass unsere PostgreSQL-Datenbank nicht mit Leseanfragen für die Bestenliste überlastet wird und die Nutzer ein nahtloses, Echtzeit-Erlebnis erhalten.

Architektur der Echtzeit-Bestenliste

Das folgende Diagramm zeigt unseren Cache-Aside-Pattern mit WebSocket-Push:

Diese Architektur ermöglicht Punktzahl-Updates unter 100ms an Tausende gleichzeitiger Nutzer.

Voraussetzungen

Bevor wir mit dem Programmieren beginnen, richten wir unsere Umgebung ein. Wir werden Docker verwenden, um schnell PostgreSQL- und Redis-Instanzen zu starten.

Erstellen Sie eine docker-compose.yml-Datei in Ihrem Projektstamm:

# docker-compose.yml
version: '3.8'
services:
  postgres:
    image: postgres:14-alpine
    restart: always
    environment:
      - POSTGRES_USER=admin
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=workout_leaderboard
    ports:
      - '5432:5432'
    volumes:
      - db_data:/var/lib/postgresql/data
  redis:
    image: redis:7-alpine
    restart: always
    ports:
      - '6379:6379'
    volumes:
      - redis_data:/data

volumes:
  db_data:
  redis_data:

Führen Sie den folgenden Befehl aus, um die Dienste zu starten:

docker-compose up -d

Sie sollten sehen, dass sowohl der postgres- als auch der redis-Container laufen.

Jetzt initialisieren wir unser Node.js-Projekt:

mkdir workout-leaderboard-api
cd workout-leaderboard-api
npm init -y
npm install express pg redis socket.io cors dotenv

Hinweis: Dieses Beispiel verwendet synthetische Workout-Scores zu Demonstrationszwecken. In der Produktion stellen Sie sicher, dass alle Gesundheitsdaten anonymisiert und gemäß HIPAA/GDPR verarbeitet werden. Bestenlisten-Rankings sollten niemals sensible Gesundheitsinformationen offenlegen.

Express-Server mit PostgreSQL- und Redis-Verbindungen initialisieren

Zunächst erstellen wir einen grundlegenden Express-Server und etablieren Verbindungen zu PostgreSQL und Redis.

Was wir tun

Wir werden einen Express-Server erstellen, eine Verbindung zu unserer PostgreSQL-Datenbank herstellen, um Benutzer- und Workout-Daten zu speichern, und eine Verbindung zu Redis für das Caching der Bestenliste aufbauen.

Implementierung

Erstellen Sie eine index.js-Datei:

// index.js
require('dotenv').config();
const express = require('express');
const http = require('http');
const { Server } = require("socket.io");
const cors = require('cors');
const { Pool } = require('pg');
const { createClient } = require('redis');

const app = express();
app.use(cors());
app.use(express.json());

const server = http.createServer(app);
const io = new Server(server, {
  cors: {
    origin: "*", // Erlaube alle Origins der Einfachheit halber
  }
});

// PostgreSQL-Verbindung
const pgClient = new Pool({
  user: 'admin',
  host: 'localhost',
  database: 'workout_leaderboard',
  password: 'password',
  port: 5432,
});
pgClient.on('connect', () => console.log('Verbunden mit PostgreSQL'));

// Redis-Verbindung
const redisClient = createClient({ url: 'redis://localhost:6379' });
redisClient.on('connect', () => console.log('Verbunden mit Redis'));
redisClient.on('error', err => console.log('Redis-Client-Fehler', err));

// Initialisierung des Datenbankschemas
const initializeDatabase = async () => {
    await pgClient.query(`
        CREATE TABLE IF NOT EXISTS users (
            id SERIAL PRIMARY KEY,
            username VARCHAR(50) UNIQUE NOT NULL,
            created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
        );

        CREATE TABLE IF NOT EXISTS workouts (
            id SERIAL PRIMARY KEY,
            user_id INTEGER REFERENCES users(id),
            score INTEGER NOT NULL,
            created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
        );
    `);
    console.log("Datenbanktabellen sind bereit.");
};

const PORT = process.env.PORT || 3001;

server.listen(PORT, async () => {
  console.log(`Server läuft auf Port ${PORT}`);
  await pgClient.connect();
  await redisClient.connect();
  await initializeDatabase();
});

io.on('connection', (socket) => {
  console.log('Ein Benutzer hat sich verbunden:', socket.id);
  socket.on('disconnect', () => {
    console.log('Benutzer getrennt:', socket.id);
  });
});

So funktioniert es

Dieser Code richtet einen Express-Server ein und integriert Socket.IO. Er erstellt auch Verbindung-Clients für sowohl PostgreSQL als auch Redis. Wenn der Server startet, verbindet er sich mit beiden Datenspeichern und führt eine Funktion aus, um sicherzustellen, dass die erforderlichen Tabellen (users, workouts) in unserer PostgreSQL-Datenbank existieren.

Score-Übermittlung mit dem Cache-Aside-Muster implementieren

Jetzt erstellen wir einen Endpunkt, um eine neue Workout-Punktzahl zu übermitteln. Hier wird unsere Cache-Aside-Logik implementiert.

Was wir tun

Wir werden einen POST /score-Endpunkt erstellen, der:

1. Die Eingabe validiert.
2. Die neue Workout-Punktzahl in die PostgreSQL-Tabelle workouts einfügt.
3. Die Gesamtpunktzahl des Benutzers im Redis-Leaderboard aktualisiert.
4. Die aktualisierte Bestenliste an alle Clients sendet.

Implementierung

Fügen Sie Folgendes zu Ihrer index.js hinzu:

// Dies vor server.listen() hinzufügen

const LEADERBOARD_KEY = 'workout_leaderboard';

// Funktion zum Abrufen der Bestenliste aus Redis
const getLeaderboard = async () => {
    const rawLeaderboard = await redisClient.zRangeWithScores(LEADERBOARD_KEY, 0, 9, { REV: true });
    // ZRANGE mit REV gibt höchste Scores zuerst zurück.

    return rawLeaderboard.map(entry => ({
        username: entry.value,
        score: entry.score,
    }));
};

app.post('/score', async (req, res) => {
    const { userId, score } = req.body;

    if (!userId || score == null) {
        return res.status(400).json({ error: 'Benutzer-ID und Punktzahl sind erforderlich.' });
    }

    try {
        // 1. In PostgreSQL schreiben (Primäre DB)
        await pgClient.query('INSERT INTO workouts(user_id, score) VALUES($1, $2)', [userId, score]);

        // 2. Score im Redis Sorted Set aktualisieren
        // ZINCRBY erhöht den Score eines Elements in einem sortierten Set
        const newTotalScore = await redisClient.zIncrBy(LEADERBOARD_KEY, score, userId.toString());
        console.log(`Neuer Gesamt-Score für Benutzer ${userId}: ${newTotalScore}`);

        // 3. Aktualisierte Bestenliste abrufen und senden
        const updatedLeaderboard = await getLeaderboard();
        io.emit('leaderboard_update', updatedLeaderboard); // An alle Clients senden

        res.status(201).json({ success: true, newTotalScore });
    } catch (error) {
        console.error('Fehler beim Übermitteln des Scores:', error);
        res.status(500).json({ error: 'Interner Serverfehler' });
    }
});

app.get('/leaderboard', async (req, res) => {
    try {
        const leaderboard = await getLeaderboard();
        res.json(leaderboard);
    } catch (error) {
        console.error('Fehler beim Abrufen der Bestenliste:', error);
        res.status(500).json({ error: 'Interner Serverfehler' });
    }
});

So funktioniert es

• PostgreSQL-Schreibvorgang: Wir schreiben zunächst die individuelle Workout-Punktzahl in PostgreSQL. Dies ist unser Datensatz.
• Redis ZINCRBY: Wir verwenden den ZINCRBY-Befehl, der atomar und unglaublich effizient ist. Er erhöht den Score für ein gegebenes Element (userId) im sortierten Set. Wenn das Element nicht existiert, wird es mit dem Score hinzugefügt. Redis sortiert das Set automatisch neu.
• Broadcast: Wir rufen dann die Top 10 aus Redis mit ZRANGE ab und senden ein leaderboard_update-Event. Alle verbundenen Clients empfangen diese neue Top-10-Liste sofort.

Das Echtzeit-Frontend mit Socket.IO-Client erstellen

Lassen Sie uns eine einfache HTML-Seite mit JavaScript erstellen, um die Bestenliste anzuzeigen und auf Echtzeit-Updates zu lauschen.

Was wir tun

Wir erstellen ein grundlegendes Frontend, das die initiale Bestenliste abruft und dann den Socket.IO-Client verwendet, um auf das leaderboard_update-Event zu lauschen, um die Anzeige zu aktualisieren.

Implementierung

Erstellen Sie einen public-Ordner in Ihrem Projektstamm und darin eine index.html-Datei.

<!-- public/index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Echtzeit-Workout-Bestenliste</title>
    <style>
        /* Fügen Sie etwas grundlegendes Styling hinzu */
        body { font-family: sans-serif; padding: 20px; }
        h1 { text-align: center; }
        #leaderboard { list-style: none; padding: 0; max-width: 500px; margin: auto; }
        #leaderboard li { display: flex; justify-content: space-between; padding: 10px; border-bottom: 1px solid #ddd; }
        #leaderboard li:nth-child(1) { font-weight: bold; background-color: #ffd700; }
    </style>
</head>
<body>
    <h1>Live-Workout-Bestenliste</h1>
    <ol id="leaderboard"></ol>

    <script src="https://cdn.socket.io/4.7.5/socket.io.min.js"></script>
    <script>
        const leaderboardList = document.getElementById('leaderboard');
        const API_URL = 'http://localhost:3001';

        // Funktion zum Rendern der Bestenliste
        function renderLeaderboard(leaderboard) {
            leaderboardList.innerHTML = '';
            leaderboard.forEach((entry, index) => {
                const li = document.createElement('li');
                li.innerHTML = `<span>${index + 1}. ${entry.username}</span> <span>${entry.score}</span>`;
                leaderboardList.appendChild(li);
            });
        }

        // Initiale Bestenlisten-Daten abrufen
        async function fetchInitialLeaderboard() {
            try {
                const response = await fetch(`${API_URL}/leaderboard`);
                const data = await response.json();
                renderLeaderboard(data);
            } catch (error) {
                console.error('Abrufen der Bestenliste fehlgeschlagen:', error);
            }
        }

        // Mit dem WebSocket-Server verbinden
        const socket = io(API_URL);

        socket.on('connect', () => {
            console.log('Verbunden mit Server mit ID:', socket.id);
        });

        // Auf Echtzeit-Updates lauschen
        socket.on('leaderboard_update', (leaderboard) => {
            console.log('Bestenlisten-Update empfangen:', leaderboard);
            renderLeaderboard(leaderboard);
        });

        socket.on('disconnect', () => {
            console.log('Verbindung zum Server getrennt');
        });

        // Initiale Ladung
        fetchInitialLeaderboard();
    </script>
</body>
</html>

Um diese Datei bereitzustellen, fügen Sie dies zu index.js hinzu:

// index.js
app.use(express.static('public'));

Leistungsaspekte

• PostgreSQL-Indizierung: Für ein Produktionssystem mit vielen Benutzern sollten Sie einen Index auf workouts(user_id) hinzufügen, um Abfragen zu beschleunigen, die möglicherweise die Gesamtpunktzahl eines Benutzers aggregieren. In unserem Design ist dies jedoch weniger kritisch, da der heiße Pfad (Lesen der Bestenliste) von Redis bedient wird.
• Redis-Speicher: Da Redis ein In-Memory-Speicher ist, stellen Sie sicher, dass Sie genügend RAM haben, um Ihre gesamte Bestenliste zu speichern. Für Millionen von Benutzern kann dies erheblich sein. Redis bietet bei Bedarf Persistenzoptionen.
• Datenkonsistenz: Es besteht eine geringe Wahrscheinlichkeit einer Inkonsistenz, wenn das Redis-Update erfolgreich ist, das PostgreSQL-Schreiben jedoch fehlschlägt. Für eine Bestenliste ist dies oft ein akzeptabler Kompromiss für die Leistung. Für unternehmenskritische Daten benötigen Sie ein komplexeres Muster mit Two-Phase-Commit oder transaktionalem Outbox-Pattern.

Bewährte Sicherheitspraktiken

• Eingabevalidierung: Validieren und bereinigen Sie Benutzereingaben immer serverseitig, bevor Sie sie verarbeiten.
• Authentifizierung: Der /score-Endpunkt sollte geschützt sein. Nur authentifizierte Benutzer sollten Scores für sich selbst posten können.
• WebSocket-Sicherheit: Implementieren Sie eine Authentifizierung für Ihre WebSocket-Verbindungen, um unautorisierte Clients am Verbinden und Lauschen auf Events zu hindern.

Fazit

Wir haben erfolgreich eine leistungsstarke, Echtzeit-Bestenliste aufgebaut. Durch die strategische Verwendung von PostgreSQL für die Datenpersistenz und Redis für seine Geschwindigkeit bei der Handhabung sortierter Daten haben wir eine Architektur geschaffen, die sowohl robust als auch skalierbar ist. Die Ergänzung von WebSockets bietet ein nahtloses, ansprechendes Echtzeit-Erlebnis für den Benutzer.

Gesundheitliche Auswirkung: Echtzeit-Bestenlisten haben sich als wirksam erwiesen, um das Benutzerengagement um 40-50% und die Trainingsabschlussquoten um 30% in Fitness-Anwendungen zu steigern. Das unmittelbare Feedback schafft eine Wettbewerbsmotivation, die Benutzer dazu antreibt, häufiger zu trainieren. Studien zeigen, dass soziale Vergleichsfunktionen wie Bestenlisten die täglichen Aktivitätsniveaus um 25% steigern und die langfristige Beibehaltung von Fitnessroutinen um 35% verbessern können.

Dieses Projekt demonstriert die Leistungsfähigkeit der Auswahl des richtigen Tools für die jeweilige Aufgabe. Anstatt eine einzelne Datenbank zu zwingen, alle Aufgaben zu bewältigen, haben wir eine Lösung zusammengestellt, die die Stärken mehrerer Technologien nutzt, um ein überlegenes Produkt zu schaffen.

Nächste Schritte für Leser:

• Benutzererstellung und Authentifizierung hinzufügen.
• Pagination oder unendliches Scrollen für die Bestenliste implementieren.
• Eine Frontend-Schnittstelle für die Score-Übermittlung erstellen.

Ressourcen

• Redis Sorted Sets Dokumentation
• Socket.IO Dokumentation
• Node.js PostgreSQL (node-postgres) Dokumentation
• Verwandte Artikel:
  • Echtzeit-Dashboard mit React & Node.js - WebSocket-Datenvisualisierung
  • Echtzeit-Pipeline mit Kafka & Flink - Stream-Verarbeitung im großen Maßstab

Kurzübersicht

Häufig gestellte Fragen

F: Wie weiß ich, ob dies auf mich zutrifft? A: Besprechen Sie Ihre persönliche und familiäre Krankengeschichte mit Ihrem Arzt, um Ihre individuellen Risikofaktoren zu bewerten und geeignete nächste Schritte zu bestimmen.

F: Was sollte ich meinen Arzt fragen? A: Gute Fragen sind: „Was bedeuten meine Ergebnisse?", „Was sind meine Optionen?", „Welche Änderungen des Lebensstils würden helfen?" und „Wann sollte ich nachuntersuchen?"

F: Gibt es Änderungen des Lebensstils, die helfen können? A: Die meisten Gesundheitszustände profitieren von grundlegenden Maßnahmen: ausgewogene Ernährung, regelmäßige körperliche Aktivität (150+ Minuten/Woche), качественний сон (7-9 Stunden), Stressbewältigung und Vermeidung von Tabak.

Haftungsausschluss

Die in diesem Artikel vorgestellten Algorithmen und Techniken dienen ausschließlich zu technischen Ausbildungszwecken. Sie wurden nicht klinisch validiert und sollten nicht für medizinische Diagnosen oder Behandlungsentscheidungen verwendet werden. Konsultieren Sie immer qualifizierte medizinische Fachkräfte für medizinische Beratung.