So testen Sie Ihren Online-Shop vor der Hochsaison (k6-Anleitung)

Jedes Jahr entdecken Geschäfte ihre Grenzen im schlechtesten Moment: während eines Verkaufs, einer TV-Erwähnung oder am Black Friday. Ein Lasttest ermöglicht es Ihnen, diese Grenzen im Voraus und nach Ihren Bedingungen zu finden.

Dieser Leitfaden zeigt, wie man einen Lasttest für einen Online-Shop mit k6, einem kostenlosen, Open-Source-Lasttest-Tool, durchführt und wie man die Ergebnisse interpretiert.

Was ein Lasttest Ihnen sagt

Wie viele gleichzeitige Käufer kann Ihr Geschäft bewältigen?
Welche Seiten verlangsamen sich zuerst (normalerweise Suche, Warenkorb und Kasse)
Wo der Engpass liegt: PHP-Arbeiter, Datenbank, Suchmaschine, externe APIs
Ob Caching unter Last funktioniert
Welche Fehlerrate würden die Kunden zu Spitzenzeiten sehen?

Arten von Tests

Test	Zweck
Smoke-Test	Kleine Last, um zu überprüfen, ob das Skript funktioniert
Lasttest	Erwarteter Spitzenverkehr über einen längeren Zeitraum
Stresstest	Erhöhen Sie, bis das System zusammenbricht, um die Grenze zu finden.
Spike-Test	Plötzlicher Anstieg des Traffics (E-Mail-Kampagne, TV-Erwähnung)
Durchlauf-Test	Normallast über Stunden, um Speicherlecks und langsame Degradation zu finden

Bevor Sie beginnen

Testen Sie gegen eine Staging- oder produktionsähnliche Umgebung mit der gleichen Hardware und Konfiguration. Wenn Sie die Produktion testen müssen, tun Sie dies zu einer ruhigen Zeit und informieren Sie Ihren Host.
Informieren Sie Ihren Hosting-Anbieter und CDN, andernfalls könnte Ihr Test als Angriff blockiert werden.
Deaktivieren Sie echte Zahlungen und E-Mails in der Testumgebung
Testverkehr von der Analyse ausschließen
Kennt eure Zielgruppe: Nutzt eure Analysen, um Spitzenzeiten für Sitzungen, Seitenaufrufe pro Minute und Bestellungen pro Stunde zu schätzen, und fügt dann eine Sicherheitsmarge hinzu.

Installiere k6

Auf Ubuntu/Debian, macOS und Windows kann k6 aus den Paketrepositories von Grafana installiert werden, mit Homebrew (brew install k6) oder über Docker. Überprüfen Sie die offizielle k6-Dokumentation für Ihr System.

Schritt 1: Ein einfaches Browsing-Szenario

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 50 },
    { duration: '5m', target: 50 },
    { duration: '2m', target: 0 },
  ],
  thresholds: {
    http_req_failed: ['rate<0.01'],
    http_req_duration: ['p(95)<1500'],
  },
};

const BASE = 'https://staging.example.com';

export default function () {
  let res = http.get(`${BASE}/`);
  check(res, { 'home 200': (r) => r.status === 200 });
  sleep(Math.random() * 3 + 2);

  res = http.get(`${BASE}/shoes/trail-running.html`);
  check(res, { 'category 200': (r) => r.status === 200 });
  sleep(Math.random() * 3 + 2);

  res = http.get(`${BASE}/trail-shoe-x200.html`);
  check(res, { 'product 200': (r) => r.status === 200 });
  sleep(Math.random() * 5 + 3);
}

Führen Sie es aus:

k6 run browse.js

Die sleep-Aufrufe simulieren echte Benutzer, die Seiten lesen. Ohne sie verhalten sich 50 virtuelle Benutzer wie Hunderte von echten Besuchern.

Schritt 2: Fügen Sie realistisches Käuferverhalten hinzu

Echter Verkehr ist eine Mischung. Eine typische Aufteilung könnte sein:

Die meisten Besucher durchsuchen die Startseite, Kategorien und Produkte.
Ein kleinerer Anteil sucht
Weniger in den Warenkorb
Ein kleiner Anteil beginnt den Checkout

Verwenden Sie separate Szenarien mit unterschiedlichen Gewichten:

export const options = {
  scenarios: {
    browsers: { executor: 'ramping-vus', exec: 'browse',
      stages: [{ duration: '3m', target: 160 }, { duration: '10m', target: 160 }] },
    searchers: { executor: 'ramping-vus', exec: 'search',
      stages: [{ duration: '3m', target: 30 }, { duration: '10m', target: 30 }] },
    buyers: { executor: 'ramping-vus', exec: 'addToCart',
      stages: [{ duration: '3m', target: 10 }, { duration: '10m', target: 10 }] },
  },
};

Basieren Sie die Aufteilung auf Ihrem eigenen Analyse-Trichter.

Schritt 3: Testen Sie das Hinzufügen zum Warenkorb und den Checkout

Warenkorb und Checkout sind die wichtigsten und am wenigsten cachebaren Teile. Das Hinzufügen zum Warenkorb erfordert normalerweise ein Sitzungs-Cookie und einen Formularschlüssel oder Nonce, die Sie von der Produktseite extrahieren müssen:

Magento: der form_key von der Seite oder dem Cookie
WooCommerce: in den Warenkorb hinzufügen über ?add-to-cart=PRODUCT_ID oder die Store-API
Shopify: die AJAX-Warenkorb-API (/cart/add.js). Hinweis: Shopify betreibt die Infrastruktur; überprüfen Sie die Richtlinien von Shopify, bevor Sie einen Lasttest eines Shopify-Shops durchführen, und konzentrieren Sie sich stattdessen auf Ihre eigenen Apps und Integrationen.

k6 speichert Cookies automatisch pro virtuellem Benutzer. Verwenden Sie check(), um zu überprüfen, ob der Warenkorb tatsächlich das Produkt enthält.

Für den Checkout testen Sie bis zum Zahlungsschritt mit einer Test-Zahlungsmethode oder simulieren Sie den Zahlungsanbieter in der Staging-Umgebung. Generieren Sie niemals echte Bestellungen bei echten Zahlungsanbietern.

Schritt 4: Überwachen Sie den Server während des Tests

Die k6-Ausgabe zeigt Antwortzeiten und Fehler. Sie müssen auch sehen warum:

CPU und Arbeitsspeicher pro Server
PHP-FPM aktive Prozesse und Warteschlange (pm.status_path)
Datenbank: Verbindungen, langsame Abfragen, Sperren
Cache-Trefferquote (Varnish, CDN, Redis)
Suchmaschinenlast (OpenSearch/Elasticsearch)
Antwortzeiten von externen APIs (Versand, Zahlung, Steuer)

Ein APM-Tool wie New Relic, Tideways oder Blackfire erleichtert das Auffinden des Engpasses erheblich.

Die Ergebnisse lesen

Metrik	Worauf man achten sollte
`http_req_duration p(95)`	95% der Anfragen schneller als dies. Sieh zu, wie es mit der Last wächst.
`http_req_failed`	Fehlerquote. Alles über einem Bruchteil eines Prozents benötigt Aufmerksamkeit.
`iterations`	Abgeschlossene Benutzerreisen
Server-CPU / PHP-Arbeiter	Saturierte Arbeiter bedeuten, dass Anfragen in die Warteschlange gestellt werden.

Der Durchbruchspunkt ist der Punkt, an dem die Reaktionszeiten stark ansteigen oder Fehler auftreten. Ihr erwarteter Höchstwert sollte deutlich unter diesem Punkt liegen.

Häufige Engpässe, die durch Lasttests gefunden werden

Zu wenige PHP-FPM-Arbeiter oder zu viele für den verfügbaren Speicher
Der vollständige Seiten-Cache funktioniert nicht für bestimmte Seiten oder Parameter
Langsame Datenbankabfragen bei der geschichteten Navigation oder Suche
Session-Speicher auf der Festplatte statt Redis (siehe Leitfaden zum Redis-Objekt-Cache)
Externe API-Aufrufe im Checkout (Versandkosten, Adressvalidierung)
Schwere Plugins oder Erweiterungen auf Warenkorbseiten

Nach der Behebung: erneut testen

Lasttests sind ein Kreislauf: testen, Engpass finden, beheben, erneut testen. Planen Sie Zeit für mindestens zwei oder drei Runden vor Ihrem Höhepunkt ein.

Häufig gestellte Fragen

Kann ich die Produktion Lasttests unterziehen?

Es ist möglich, aber riskant. Bevorzuge eine produktionsähnliche Testumgebung. Wenn du in der Produktion testest, tue dies nachts, beginne klein und informiere deinen Host.

Wie viele virtuelle Benutzer benötige ich?

Berechnen Sie aus den Analysen: Spitzenanzahl gleichzeitiger Sitzungen, mit realistischen Denkzeiten, plus einer Sicherheitsmarge. Virtuelle Benutzer mit Pausen sind nicht dasselbe wie Seitenaufrufe pro Sekunde.

Ist k6 kostenlos?

Das k6-Befehlszeilenwerkzeug ist Open Source. Grafana bietet auch einen Cloud-Service für größere verteilte Tests an.

Möchten Sie einen professionellen Lasttest?

Ich führe Lasttests für Magento- und WooCommerce-Shops durch, finde die Engpässe und behebe sie vor der Hochsaison. Siehe meinen Server- und Backup-Service oder fordere einen Lasttest an.