Apache JMeter Cheatsheet¶

Installation¶

Plattform	Befehl
Ubuntu/Debian	`sudo apt update && sudo apt install jmeter`
Ubuntu (Snap)	`sudo snap install jmeter`
macOS (Homebrew)	`brew install jmeter`
Windows (Chocolatey)	`choco install jmeter`
Binary (Linux/macOS)	`wget https://dlcdn.apache.org//jmeter/binaries/apache-jmeter-5.6.3.tgz && tar -xzf apache-jmeter-5.6.3.tgz`
Docker	`docker pull justb4/jmeter:latest`
Prerequisites	Java JDK 8+ required: `java -version`
`# Add JMeter to PATH (Linux/macOS) export JMETER_HOME=/opt/apache-jmeter-5.6.3 export PATH=$PATH:$JMETER_HOME/bin # Verify installation jmeter --version # Increase heap size (add to ~/.bashrc or jmeter startup script) export JVM_ARGS="-Xms1g -Xmx4g"`

Grundlegende Befehle¶

Befehl	Beschreibung
`jmeter`	JMeter GUI starten
`jmeter -t test-plan.jmx`	Öffnen Sie den spezifischen Testplan in der GUI
`jmeter -n -t test.jmx -l results.jtl`	Test im Non-GUI-Modus ausführen mit Ergebnissen
`jmeter -n -t test.jmx -l results.jtl -e -o report/`	Test ausführen und HTML-Dashboard generieren
`jmeter --version` or `jmeter -v`	JMeter-Version anzeigen
`jmeter --help` or `jmeter -h`	Hilfe und verfügbare Optionen anzeigen
`jmeter -?`	Alle verfügbaren Eigenschaften auflisten
`jmeter -n -t test.jmx -j jmeter.log`	Test mit benutzerdefinierter Logdatei ausführen
`jmeter -g results.jtl -o dashboard/`	HTML-Bericht aus vorhandenen Ergebnissen generieren
`jmeter -p custom.properties`	Start mit benutzerdefinierter Eigenschaften-Datei
`jmeter -Xmx4g`	Start mit erhöhter Heap-Größe (4GB)
`jmeter-server`	JMeter im Servermodus für verteiltes Testen starten
`jmeter -n -t test.jmx -l results.csv`	Test ausführen und Ergebnisse als CSV speichern
`jmeter -n -t test.jmx -l results.xml`	Test ausführen und Ergebnisse als XML speichern
`jmeter -Jusers=100`	Eigenschaftswert zur Laufzeit überschreiben
## Erweiterte Nutzung

Befehl	Beschreibung
`jmeter -n -t test.jmx -r`	Test auf allen Remote-Servern durchführen
`jmeter -n -t test.jmx -R server1:1099,server2:1099`	Test auf bestimmten Remote-Servern durchführen
`jmeter -n -t test.jmx -Gusers=100 -Grampup=60`	Globale Eigenschaften für Remote-Server festlegen
`jmeter -n -t test.jmx -r -X`	Verteilten Test ausführen und Remote-Server danach beenden
`jmeter -n -t test.jmx -q env.properties -q users.properties`	Verwenden Sie mehrere Eigenschaftendateien
`jmeter -H proxy.example.com -P 8080`	Mit HTTP-Proxy ausführen
`jmeter -H proxy.com -P 8080 -u username -a password`	Mit authentifiziertem Proxy ausführen
`jmeter -Lorg.apache.jmeter=DEBUG`	Setze Log-Level auf DEBUG
`jmeter -Lorg.apache.jmeter.protocol.http=DEBUG`	Log-Level für spezifisches Paket festlegen
`jmeter-server -Djava.rmi.server.hostname=192.168.1.100`	Server mit spezifischem Hostnamen starten
`jmeter-server -Dserver_port=1099`	Server auf benutzerdefiniertem Port starten
`jmeter -n -t test.jmx -Jsummariser.interval=30`	Zusammenfassungsintervall auf 30 Sekunden setzen
`jmeter -n -t test.jmx -Jjmeter.save.saveservice.output_format=xml`	XML-Ausgabeformat erzwingen
`jmeter -n -t test.jmx -Jjmeter.save.saveservice.response_data=true`	Antwortdaten in Ergebnisse einbeziehen
`jmeter -XX:+UseG1GC -n -t test.jmx`	Mit G1-Garbage-Collector ausführen
`jmeter -Dcom.sun.management.jmxremote -n -t test.jmx`	JMX-Monitoring aktivieren
`jmeter -Dhttp.keepAlive=false -n -t test.jmx`	HTTP Keep-Alive deaktivieren
`jmeter -g results.jtl -o dashboard/ -f`	Vorhandenes Dashboard überschreiben erzwingen
`jmeter -N "localhost \| *.internal.com"`	Nicht-Proxy-Hosts festlegen
`PluginsManagerCMD.sh install jpgc-casutg,jpgc-synthesis`	JMeter-Plugins über CLI installieren
## Konfiguration

JMeter Eigenschaften-Datei (`jmeter.properties`)¶

# Thread and ramp-up settings
jmeter.threads=100
jmeter.rampup=60

# Remote server configuration
remote_hosts=server1:1099,server2:1099,server3:1099

# Result file configuration
jmeter.save.saveservice.output_format=csv
jmeter.save.saveservice.response_data=false
jmeter.save.saveservice.samplerData=false
jmeter.save.saveservice.requestHeaders=false
jmeter.save.saveservice.url=true
jmeter.save.saveservice.responseHeaders=false

# HTTP settings
httpclient.reset_state_on_thread_group_iteration=true
http.keepAlive=true
http.connection.timeout=30000
http.socket.timeout=120000

# Summariser interval (seconds)
summariser.interval=30

# Log level
log_level.jmeter=INFO
log_level.jmeter.engine=DEBUG

Benutzer-Eigenschaften-Datei (`user.properties`)¶

# Custom variables
baseurl=https://example.com
users=100
rampup=60
duration=300

# Environment-specific settings
env=production
api_key=your_api_key_here

Systemeigenschaften¶

# Set system properties via command line
jmeter -Dhttp.proxyHost=proxy.example.com \
       -Dhttp.proxyPort=8080 \
       -Dhttps.proxyHost=proxy.example.com \
       -Dhttps.proxyPort=8080 \
       -n -t test.jmx

JVM-Konfiguration (`jmeter`Skript)¶

# Edit JMETER_HOME/bin/jmeter or set environment variable
export HEAP="-Xms1g -Xmx4g -XX:MaxMetaspaceSize=256m"
export GC_ALGO="-XX:+UseG1GC -XX:MaxGCPauseMillis=100 -XX:G1ReservePercent=20"
export JVM_ARGS="$HEAP $GC_ALGO"

Konfiguration für verteiltes Testen¶

# In jmeter.properties on controller machine
remote_hosts=192.168.1.101:1099,192.168.1.102:1099,192.168.1.103:1099

# Server RMI configuration
server.rmi.ssl.disable=true
server.rmi.localport=4000
server_port=1099

# On remote server machines
java.rmi.server.hostname=192.168.1.101

Häufige Anwendungsfälle¶

Anwendungsfall 1: Grundlegender Lasttest mit HTML-Bericht¶

# Run load test with 100 users, 60s ramp-up, generate HTML report
jmeter -n -t load-test.jmx \
       -Jusers=100 \
       -Jrampup=60 \
       -Jduration=300 \
       -l results/results.jtl \
       -e -o results/dashboard/ \
       -j results/jmeter.log

# View the report
open results/dashboard/index.html  # macOS
xdg-open results/dashboard/index.html  # Linux

Anwendungsfall 2: Verteilter Lasttest über mehrere Server¶

# Step 1: Start JMeter servers on remote machines
# On server1 (192.168.1.101):
jmeter-server -Djava.rmi.server.hostname=192.168.1.101

# On server2 (192.168.1.102):
jmeter-server -Djava.rmi.server.hostname=192.168.1.102

# Step 2: Run distributed test from controller
jmeter -n -t distributed-test.jmx \
       -R 192.168.1.101:1099,192.168.1.102:1099 \
       -Gusers=500 \
       -Grampup=120 \
       -l distributed-results.jtl \
       -e -o distributed-report/

# Step 3: Shutdown remote servers
jmeter -n -t distributed-test.jmx -R 192.168.1.101:1099,192.168.1.102:1099 -X

Anwendungsfall 3: API-Performance-Test mit mehreren Umgebungen¶

# Create environment-specific property files
# dev.properties:
echo "baseurl=https://dev-api.example.com" > dev.properties
echo "api_key=dev_key_123" >> dev.properties

# prod.properties:
echo "baseurl=https://api.example.com" > prod.properties
echo "api_key=prod_key_456" >> prod.properties

# Run test against dev environment
jmeter -n -t api-test.jmx \
       -q dev.properties \
       -Jusers=50 \
       -l dev-results.jtl \
       -e -o dev-report/

# Run test against production environment
jmeter -n -t api-test.jmx \
       -q prod.properties \
       -Jusers=200 \
       -l prod-results.jtl \
       -e -o prod-report/

Anwendungsfall 4: CI/CD-Integration (Jenkins/GitLab)¶

#!/bin/bash
# performance-test.sh - CI/CD pipeline script

# Set variables
TEST_PLAN="test-plans/load-test.jmx"
RESULTS_DIR="results/$(date +%Y%m%d_%H%M%S)"
USERS=${USERS:-100}
DURATION=${DURATION:-300}

# Create results directory
mkdir -p $RESULTS_DIR

# Run JMeter test
jmeter -n -t $TEST_PLAN \
       -Jusers=$USERS \
       -Jduration=$DURATION \
       -l $RESULTS_DIR/results.jtl \
       -e -o $RESULTS_DIR/dashboard/ \
       -j $RESULTS_DIR/jmeter.log

# Check for errors (exit code)
if [ $? -eq 0 ]; then
    echo "Test completed successfully"

    # Archive results
    tar -czf $RESULTS_DIR.tar.gz $RESULTS_DIR

    # Optional: Upload to artifact storage
    # aws s3 cp $RESULTS_DIR.tar.gz s3://bucket/results/
else
    echo "Test failed with errors"
    exit 1
fi

Anwendungsfall 5: Datenbank-Performance-Test¶

# Test database performance with parameterized queries
jmeter -n -t database-test.jmx \
       -Jdb.host=db.example.com \
       -Jdb.port=5432 \
       -Jdb.name=testdb \
       -Jdb.user=testuser \
       -Jdb.password=testpass \
       -Jthreads=50 \
       -Jrampup=30 \
       -l db-results.jtl \
       -e -o db-report/

# Generate report from existing results
jmeter -g db-results.jtl -o db-report-regenerated/

Bewährte Praktiken¶

Verwenden Sie immer den Nicht-GUI-Modus für tatsächliche Tests: Der GUI-Modus verbraucht erhebliche Ressourcen und beeinträchtigt die Testgenauigkeit. Verwenden Sie jmeter -nfür alle Performance-Tests.
Weisen Sie ausreichend Heap-Speicher zu: Setzen Sie die JVM-Heap-Größe auf mindestens 25% des verfügbaren RAMs. Für große Tests:export JVM_ARGS="-Xms2g -Xmx4g -XX:+UseG1GC"
CSV-Format für Ergebnisdateien verwenden: CSV-Format ist effizienter als XML. Deaktivieren Sie unnötige Datensammlung, um Overhead zu reduzieren: jmeter.save.saveservice.response_data=false
Ordnungsgemäße Anlaufperioden implementieren: Vermeiden Sie das gleichzeitige Starten aller Threads. Verwenden Sie einen graduellen Anlauf (typischerweise 10-20% der Testdauer), um realistische Lastmuster zu simulieren.
Verteiltes Testen für hohe Lasten nutzen: Einschränkungen einer einzelnen Maschine können Ergebnisse verzerren. Verwenden Sie mehrere JMeter-Server für Tests mit mehr als 500-1000 Threads.
Testdaten parametrisieren: Verwenden Sie CSV Data Set Config oder Variablen anstelle von hartcodierten Werten. Dies ermöglicht eine einfache Testkonfiguration und Umgebungsumstellung.
Systemressourcen während der Tests überwachen: Verfolgen Sie CPU, Arbeitsspeicher, Netzwerk und Festplatten-I/O auf JMeter-Maschinen und Zielsystemen. Hohe Ressourcenauslastung auf JMeter deutet auf Engpässe bei der Testausführung hin.
Testpläne unter Versionskontrolle stellen: .jmxDateien und Eigenschaftsdateien in Git speichern. Verwenden Sie aussagekräftige Commit-Nachrichten und markieren Sie Releases für Reproduzierbarkeit.
Ordnungsgemäße Korrelation und Assertionen implementieren: Extrahieren Sie dynamische Werte (Token, Session-IDs) und validieren Sie Antworten. Messen Sie nicht nur die Geschwindigkeit - überprüfen Sie die Korrektheit.
Zwischen Testläufen aufräumen: Ergebnisverzeichnisse und Logs löschen. Setzen Sie den Anwendungszustand bei Bedarf zurück, um konsistente Testbedingungen zu gewährleisten.

Fehlerbehebung¶

Problem	Lösung
OutOfMemoryError during test	Increase heap size: `export JVM_ARGS="-Xms2g -Xmx4g"` or reduce threads/disable response data saving
Connection refused on remote servers	Check firewall rules for ports 1099 and 4000. Verify `java.rmi.server.hostname` is set correctly on server
Test results show 100% errors	Verify target URL is accessible, check proxy settings, review `jmeter.log` for detailed error messages
GUI freezes during large tests	Never run large tests in GUI mode. Use non-GUI: `jmeter -n -t test.jmx -l results.jtl`
Inconsistent results between runs	Sicherstellen des ordnungsgemäßen Hochfahrens, Cache/Cookies zwischen Durchläufen löschen, Netzwerkstabilität überprüfen, Auslastung des Zielsystems prüfen
Cannot generate HTML report	Verify results file format is compatible (CSV/JTL), ensure output directory is empty or use `-f` flag to force overwrite
Remote servers not starting	Check Java version compatibility (JDK 8+), verify RMI registry port is available, review `jmeter-server.log`
SSL/TLS certificate errors	Add certificate to Java keystore or disable validation: `jmeter -Jhttps.default.protocol=TLSv1.2`
Slow test execution	Listener in Nicht-GUI-Modus deaktivieren, Assertionskomplexität reduzieren, reguläre Ausdrücke optimieren, effiziente Extraktoren verwenden
"Non HTTP response code: java.net.SocketException"	Erhöhen Sie Timeout-Werte, überprüfen Sie Connection-Pool-Einstellungen, verifizieren Sie Kapazität des Zielsystems, reduzieren Sie Thread-Anzahl
Distributed test results incomplete	Stellen Sie sicher, dass alle Server die gleiche Testplan-Version haben, überprüfen Sie die Netzwerkverbindung, verifizieren Sie die Uhrzeitsynschronisation über alle Server
High CPU on JMeter machine	Reduzieren Sie die Thread-Anzahl, deaktivieren Sie unnötige Prozessoren/Listener, verwenden Sie einfachere Sampler, erwägen Sie verteiltes Testen
Cannot install plugins	Download Plugins Manager JAR manually to `lib/ext/`, ensure internet connectivity, check proxy settings
Results file corrupted or empty	Stellen Sie ausreichenden Festplattenspeicher sicher, überprüfen Sie Dateiberechtigungen, verifizieren Sie, dass der JMeter-Prozess erfolgreich abgeschlossen wurde
"Address already in use" error	Change server port: `jmeter-server -Dserver_port=1100`, kill existing JMeter processes, wait for port release
## Schnellreferenz: Befehlszeilenoptionen

Option	Beschreibung	Beispiel
`-n`	Nicht-GUI-Modus	`jmeter -n -t test.jmx`
`-t`	Test-Plan-Datei	`jmeter -t mytest.jmx`
`-l`	Ergebnisprotokoll-Datei	`jmeter -n -t test.jmx -l results.jtl`
`-j`	JMeter-Protokolldatei	`jmeter -n -t test.jmx -j jmeter.log`
`-r`	Auf allen Remote-Servern ausführen	`jmeter -n -t test.jmx -r`
`-R`	Auf bestimmten Servern ausführen	`jmeter -n -t test.jmx -R server1,server2`
`-g`	Bericht aus Datei generieren	`jmeter -g results.jtl -o report/`
`-e`	Bericht nach Test generieren	`jmeter -n -t test.jmx -l results.jtl -e -o report/`
`-o`	Ausgabeordner für Bericht	`jmeter -g results.jtl -o dashboard/`
`-H`	Proxy-Host	`jmeter -H proxy.com -P 8080`
`-P`	Proxy-Port	`jmeter -H proxy.com -P 8080`
`-u`	Proxy-Benutzername	`jmeter -H proxy.com -P 8080 -u user`
`-a`	Proxy-Passwort	`jmeter -H proxy.com -P 8080 -a pass`
`-J`	JMeter-Eigenschaft definieren	`jmeter -Jusers=100 -Jrampup=60`
`-G`	Globale Eigenschaft definieren	`jmeter -Gusers=100` (for remote servers)
`-D`	Systemeigenschaft definieren	`jmeter -Dhttp.proxyHost=proxy.com`
`-L`	Log-Level festlegen	`jmeter -Lorg.apache.jmeter=DEBUG`
`-p`	Property-Datei	`jmeter -p custom.properties`
`-q`	Zusätzliche Eigenschaftsdatei	`jmeter -q env.properties`
`-X`	Remote-Server verlassen	`jmeter -n -t test.jmx -r -X`

Apache JMeter Cheatsheet¶

Installation¶

Grundlegende Befehle¶

JMeter Eigenschaften-Datei (jmeter.properties)¶

Benutzer-Eigenschaften-Datei (user.properties)¶

Systemeigenschaften¶

JVM-Konfiguration (jmeterSkript)¶

Konfiguration für verteiltes Testen¶

Häufige Anwendungsfälle¶

Anwendungsfall 1: Grundlegender Lasttest mit HTML-Bericht¶

Anwendungsfall 2: Verteilter Lasttest über mehrere Server¶

Anwendungsfall 3: API-Performance-Test mit mehreren Umgebungen¶

Anwendungsfall 4: CI/CD-Integration (Jenkins/GitLab)¶

Anwendungsfall 5: Datenbank-Performance-Test¶

Bewährte Praktiken¶

Fehlerbehebung¶

JMeter Eigenschaften-Datei (`jmeter.properties`)¶

Benutzer-Eigenschaften-Datei (`user.properties`)¶

JVM-Konfiguration (`jmeter`Skript)¶