Ausrüstungspflege

Ausrüstungspflege

Die ordnungsgemäße Wartung Ihrer Abonnement-Management-Infrastruktur und Entwicklungstools ist für optimale Leistung und Zuverlässigkeit von entscheidender Bedeutung. Dieser Leitfaden behandelt bewährte Verfahren für die Wartung Ihrer ToroSachi-Integration und verwandter Systeme.

Infrastruktur-Wartung

Server-Gesundheits-Überwachung

Systemanforderungen

Stellen Sie sicher, dass Ihre Infrastruktur diese Mindestanforderungen erfüllt:

• CPU: 2+ Kerne für Produktionsumgebungen
• RAM: 4GB Minimum, 8GB empfohlen
• Speicher: SSD empfohlen für Datenbankoperationen
• Netzwerk: Stabile Internetverbindung mit 99,9% Verfügbarkeit
• SSL: Gültiges SSL-Zertifikat für alle Endpunkte

Überwachungs-Checkliste

Tägliche Prüfungen:

• API-Antwortzeiten < 500ms
• Webhook-Zustellungsrate > 99%
• Datenbankverbindungspool-Gesundheit
• SSL-Zertifikatsgültigkeit
• Protokolldateigrößen und -rotation

Wöchentliche Wartung:

• Installation von Sicherheitsupdates
• Datenbankoptimierung und -bereinigung
• Protokollanalyse und -archivierung
• Überprüfung der Leistungsmetriken
• Backup-Verifizierung

Monatliche Überprüfungen:

• Kapazitätsplanung-Bewertung
• Sicherheitsaudit und Schwachstellen-Scanning
• Disaster-Recovery-Tests
• Analyse der Leistungstrends
• Kostenoptimierung-Überprüfung

Datenbankpflege

PostgreSQL-Wartung

Für PostgreSQL-Datenbanken, die Abonnement-Daten speichern:

-- Wöchentliche Wartungsabfragen
VACUUM ANALYZE subscriptions;
VACUUM ANALYZE payments;
VACUUM ANALYZE customers;

-- Monatliche Index-Wartung
REINDEX INDEX idx_subscriptions_status;
REINDEX INDEX idx_payments_created_at;

-- Datenbankgröße prüfen
SELECT
  schemaname,
  tablename,
  pg_size_pretty(pg_total_relation_size(tablename::text)) as size
FROM pg_tables
WHERE schemaname = 'public'
ORDER BY pg_total_relation_size(tablename::text) DESC;

Automatisiertes Backup-Skript

#!/bin/bash
# Tägliches Backup-Skript

DB_NAME="torosachi_prod"
BACKUP_DIR="/backups/database"
DATE=$(date +%Y%m%d_%H%M%S)

# Backup erstellen
pg_dump $DB_NAME > "$BACKUP_DIR/backup_$DATE.sql"

# Backup komprimieren
gzip "$BACKUP_DIR/backup_$DATE.sql"

# Backups älter als 30 Tage entfernen
find $BACKUP_DIR -name "backup_*.sql.gz" -mtime +30 -delete

# Backup-Integrität verifizieren
gunzip -t "$BACKUP_DIR/backup_$DATE.sql.gz"

if [ $? -eq 0 ]; then
    echo "Backup erfolgreich: backup_$DATE.sql.gz"
else
    echo "Backup-Verifizierung fehlgeschlagen!"
    exit 1
fi

API-Integrations-Pflege

Rate-Limit-Management

Best Practices

• Implementieren Sie exponentielles Backoff für Wiederholungen
• Cachen Sie häufig abgerufene Daten
• Verwenden Sie Bulk-Operationen wenn verfügbar
• Überwachen Sie Rate-Limit-Header

// Rate-Limit-bewusster HTTP-Client
class ToroSachiClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.rateLimitRemaining = 1000;
    this.rateLimitReset = Date.now();
  }

  async makeRequest(endpoint, options = {}) {
    // Rate Limit prüfen
    if (this.rateLimitRemaining <= 10 && Date.now() < this.rateLimitReset) {
      const waitTime = this.rateLimitReset - Date.now();
      await new Promise(resolve => setTimeout(resolve, waitTime));
    }

    const response = await fetch(`https://api.torosachi.com/v1${endpoint}`, {
      ...options,
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json',
        ...options.headers
      }
    });

    // Rate-Limit-Informationen aktualisieren
    this.rateLimitRemaining = parseInt(response.headers.get('X-RateLimit-Remaining'));
    this.rateLimitReset = parseInt(response.headers.get('X-RateLimit-Reset')) * 1000;

    return response;
  }
}

Entwicklungsumgebungs-Pflege

Versionskontroll-Hygiene

Git-Repository-Wartung

# Regelmäßige Bereinigung
git gc --aggressive --prune=now
git remote prune origin

# Gemergete Branches entfernen
git branch --merged | grep -v "\*\|main\|master" | xargs -n 1 git branch -d

# Submodule aktualisieren
git submodule update --remote --merge

# Repository-Integrität verifizieren
git fsck --full

Branch-Management

• Gemergete Feature-Branches zeitnah löschen
• Konventionelle Commit-Nachrichten verwenden
• Langlebige Branches regelmäßig rebasen
• Commits vor dem Merge zu main squashen

Sicherheits-Wartung

API-Schlüssel-Rotation

Geplante Schlüssel-Rotation

#!/bin/bash
# Monatliches API-Schlüssel-Rotations-Skript

# Neuen API-Schlüssel generieren
NEW_KEY=$(curl -X POST https://api.torosachi.com/v1/keys \
  -H "Authorization: Bearer $CURRENT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Production Key '$(date +%Y%m)'"}')

# Umgebungsvariablen aktualisieren
echo "TOROSACHI_API_KEY=$NEW_KEY" > .env.new

# Neuen Schlüssel testen
if curl -f https://api.torosachi.com/v1/account \
   -H "Authorization: Bearer $NEW_KEY" > /dev/null 2>&1; then
  mv .env.new .env
  echo "API-Schlüssel erfolgreich rotiert"

  # Alten Schlüssel nach Übergangsfrist widerrufen
  sleep 300
  curl -X DELETE https://api.torosachi.com/v1/keys/$OLD_KEY_ID \
    -H "Authorization: Bearer $NEW_KEY"
else
  echo "Test des neuen API-Schlüssels fehlgeschlagen"
  rm .env.new
  exit 1
fi

Leistungsoptimierung

Abfrage-Leistung

Datenbankabfrage-Optimierung

-- Langsame Abfragen identifizieren
SELECT
  query,
  mean_time,
  calls,
  total_time
FROM pg_stat_statements
ORDER BY mean_time DESC
LIMIT 10;

-- Notwendige Indizes erstellen
CREATE INDEX CONCURRENTLY idx_subscriptions_customer_status
ON subscriptions(customer_id, status)
WHERE status IN ('active', 'trialing');

Cache-Wartung

Redis-Cache-Management

# Redis-Wartungsbefehle
redis-cli INFO memory
redis-cli INFO stats

# Abgelaufene Schlüssel löschen
redis-cli SCAN 0 MATCH "expired:*" | xargs redis-cli DEL

# Schlüssel-Ablauf überwachen
redis-cli --latency-history -i 1

# Speichernutzung optimieren
redis-cli CONFIG SET maxmemory-policy allkeys-lru

Überwachung und Alarmierung

Gesundheitsprüfungs-Endpunkte

Umfassende Gesundheitsprüfung

app.get('/health', async (req, res) => {
  const health = {
    status: 'healthy',
    timestamp: new Date().toISOString(),
    checks: {}
  };

  try {
    // Datenbank-Konnektivität
    const dbResult = await db.query('SELECT 1');
    health.checks.database = { status: 'healthy', responseTime: dbResult.duration };

    // Externe API-Konnektivität
    const apiStart = Date.now();
    await fetch('https://api.torosachi.com/v1/health');
    health.checks.externalAPI = { status: 'healthy', responseTime: Date.now() - apiStart };

    res.status(200).json(health);
  } catch (error) {
    health.status = 'unhealthy';
    health.error = error.message;
    res.status(503).json(health);
  }
});

Disaster Recovery

Backup-Verifizierung

Regelmäßige Wiederherstellungstests

#!/bin/bash
# Monatlicher Backup-Wiederherstellungstest

TEST_DB="torosachi_test_restore"
BACKUP_FILE="/backups/database/latest.sql.gz"

# Test-Datenbank erstellen
createdb $TEST_DB

# Aus Backup wiederherstellen
gunzip -c $BACKUP_FILE | psql $TEST_DB

# Datenintegrität verifizieren
RECORD_COUNT=$(psql $TEST_DB -t -c "SELECT COUNT(*) FROM subscriptions")
EXPECTED_COUNT=1000  # Je nach Ihren Daten anpassen

if [ $RECORD_COUNT -ge $EXPECTED_COUNT ]; then
    echo "Backup-Wiederherstellungstest bestanden: $RECORD_COUNT Datensätze gefunden"
else
    echo "Backup-Wiederherstellungstest fehlgeschlagen: nur $RECORD_COUNT Datensätze gefunden"
    exit 1
fi

# Aufräumen
dropdb $TEST_DB

---

Regelmäßige Wartung ist der Schlüssel zu zuverlässigen Abonnement-Management-Systemen. Überprüfen Sie diesen Leitfaden monatlich und aktualisieren Sie die Verfahren, während sich Ihre Infrastruktur weiterentwickelt.