Aller au contenu
1337skills 1337skills - Aide-mémoires

Guide de Performance Gatling

Guide de Performance Gatling

Installation

PlateformeCommande
Ubuntu/Debianwget https://repo1.maven.org/maven2/io/gatling/highcharts/gatling-charts-highcharts-bundle/3.10.3/gatling-charts-highcharts-bundle-3.10.3-bundle.zip && unzip gatling-charts-highcharts-bundle-3.10.3-bundle.zip && sudo mv gatling-charts-highcharts-bundle-3.10.3 /opt/gatling
macOS (Homebrew)brew install gatling
Windows (Manual)Download from Maven Central, extract to C:\gatling, add bin directory to PATH
SDKMAN (Linux/Mac)sdk install gatling
Dockerdocker pull denvazh/gatling:latest
Maven PluginAdd io.gatling:gatling-maven-plugin:4.6.0 to pom.xml
Gradle PluginAdd id 'io.gatling.gradle' version '3.10.3' to build.gradle
# Install Java 11+ (required)
sudo apt install openjdk-11-jdk -y  # Ubuntu/Debian
brew install openjdk@11              # macOS

# Verify Java installation
java -version

Commandes de Base

CommandeDescription
gatling.shLancer le mode interactif pour sélectionner et exécuter des simulations
gatling.sh -s com.example.MySimulationExécuter une classe de simulation spécifique
gatling.bat -s com.example.MySimulationExécuter la simulation sur Windows
gatling.sh --helpAfficher l’aide et les options disponibles
gatling.sh --versionAfficher la version de Gatling
recorder.shLancez l’interface graphique de Gatling Recorder pour enregistrer des sessions de navigateur
recorder.batLancer Recorder sur Windows
gatling.sh -ro simulation-folder-nameGénérer des rapports à partir des journaux de simulation existants
gatling.sh -s MySimulation -nrExécuter la simulation sans générer de rapports
gatling.sh -s MySimulation -rd "Test description"Exécuter avec une description personnalisée pour les rapports
mvn gatling:testExécuter tous les tests Gatling à l’aide de Maven
mvn gatling:test -Dgatling.simulationClass=MySimulationExécuter une simulation spécifique avec Maven
gradle gatlingRunExécuter tous les tests Gatling à l’aide de Gradle
gradle gatlingRun-com.example.MySimulationExécuter une simulation spécifique avec Gradle
ls user-files/simulations/Lister les fichiers de simulation disponibles

Utilisation Avancée

CommandeDescription
gatling.sh -s MySimulation -rf /custom/resultsExécuter avec un dossier de résultats personnalisé
gatling.sh -s MySimulation -bf /custom/binariesExécuter avec un répertoire de binaires personnalisé
gatling.sh -s MySimulation -rsf /custom/resourcesExécuter avec un répertoire de ressources personnalisé
gatling.sh -s MySimulation -df /custom/dataExécuter avec un répertoire de données personnalisé
gatling.sh -s MySimulation -cf /path/to/gatling.confExécuter avec un fichier de configuration personnalisé
JAVA_OPTS="-Xms2G -Xmx4G" gatling.sh -s MySimulationExécuter avec des paramètres de mémoire JVM personnalisés
gatling.sh -s MySimulation -D baseUrl=https://api.example.comTransmettre les propriétés système à la simulation
gatling.sh -s MySimulation -D users=100 -D duration=300Passer plusieurs propriétés système
mvn gatling:test -Dgatling.jvmArgs="-Xms2G -Xmx4G"Maven exécuté avec des arguments JVM personnalisés
docker run -v $(pwd)/user-files:/opt/gatling/user-files denvazh/gatlingExécuter Gatling dans un conteneur Docker
gatling.sh -s Sim1 && gatling.sh -s Sim2Exécuter plusieurs simulations séquentiellement
for sim in Sim1 Sim2; do gatling.sh -s $sim -nr; doneExécuter des simulations par lots sans rapports
mvn clean gatling:test -DbaseUrl=https://prod.example.comMaven run avec URL spécifique à l’environnement
gradle gatlingRun -Dusers=500 -Dduration=600Gradle run avec des paramètres dynamiques
`gatling.sh -s MySimulation 2>&1tee test.log`

Configuration

Fichier de Configuration Principal (gatling.conf)

gatling {
  core {
    # Output directory for results
    outputDirectoryBaseName = "simulation"
    
    # Encoding for files
    encoding = "utf-8"
    
    # Timeout for requests
    timeOut = 60000
    
    # Directory for simulation classes
    simulationClass = ""
  }
  
  http {
    # Enable/disable SSL/TLS
    enableGA = false
    
    # Connection timeout
    connectTimeout = 10000
    
    # Request timeout
    requestTimeout = 60000
    
    # Max connections per host
    maxConnectionsPerHost = 6
  }
  
  data {
    # Directory for feeder files
    file {
      bufferSize = 256
    }
  }
  
  charting {
    # Indicators percentiles
    indicators {
      lowerBound = 800
      higherBound = 1200
      percentile1 = 50
      percentile2 = 75
      percentile3 = 95
      percentile4 = 99
    }
  }
}

Configuration des Propriétés Système

# Set via command line
gatling.sh -s MySimulation \
  -Dgatling.core.outputDirectoryBaseName=custom-output \
  -Dgatling.http.requestTimeout=30000 \
  -Dgatling.charting.indicators.percentile1=90

Configuration Maven (pom.xml)

<plugin>
    <groupId>io.gatling</groupId>
    <artifactId>gatling-maven-plugin</artifactId>
    <version>4.6.0</version>
    <configuration>
        <simulationClass>com.example.MySimulation</simulationClass>
        <jvmArgs>
            <jvmArg>-Xms2G</jvmArg>
            <jvmArg>-Xmx4G</jvmArg>
            <jvmArg>-XX:+UseG1GC</jvmArg>
        </jvmArgs>
        <systemProperties>
            <baseUrl>https://api.example.com</baseUrl>
            <users>100</users>
        </systemProperties>
    </configuration>
</plugin>

Configuration Gradle (build.gradle)

gatling {
    simulations = {
        include 'com/example/**/*Simulation.scala'
    }
    
    jvmArgs = ['-Xms2G', '-Xmx4G', '-XX:+UseG1GC']
    
    systemProperties = [
        'baseUrl': 'https://api.example.com',
        'users': '100'
    ]
}

Cas d’Utilisation Courants

Cas d’Utilisation 1 : Test de Charge API de Base

# Create simulation file
cat > user-files/simulations/BasicApiTest.scala << 'EOF'
import io.gatling.core.Predef._
import io.gatling.http.Predef._
import scala.concurrent.duration._

class BasicApiTest extends Simulation {
  val httpProtocol = http
    .baseUrl("https://api.example.com")
    .acceptHeader("application/json")
    .contentTypeHeader("application/json")

  val scn = scenario("Basic API Test")
    .exec(http("Get Users")
      .get("/users")
      .check(status.is(200)))
    .pause(1)

  setUp(
    scn.inject(
      rampUsers(100) during (60 seconds)
    )
  ).protocols(httpProtocol)
}
EOF

# Run the test
gatling.sh -s BasicApiTest

# View results
open results/basicapitest-*/index.html  # macOS
xdg-open results/basicapitest-*/index.html  # Linux

Cas d’Utilisation 2 : Test de Stress avec Charge Progressive

# Create stress test simulation
cat > user-files/simulations/StressTest.scala << 'EOF'
import io.gatling.core.Predef._
import io.gatling.http.Predef._
import scala.concurrent.duration._

class StressTest extends Simulation {
  val httpProtocol = http.baseUrl("https://api.example.com")

  val scn = scenario("Stress Test")
    .exec(http("Heavy Endpoint")
      .post("/api/process")
      .body(StringBody("""{"data": "test"}"""))
      .check(status.is(200)))

  setUp(
    scn.inject(
      nothingFor(5 seconds),
      atOnceUsers(10),
      rampUsers(50) during (30 seconds),
      constantUsersPerSec(20) during (60 seconds),
      rampUsersPerSec(20) to 50 during (60 seconds)
    )
  ).protocols(httpProtocol)
    .maxDuration(5 minutes)
    .assertions(
      global.responseTime.max.lt(5000),
      global.successfulRequests.percent.gt(95)
    )
}
EOF

# Run with custom memory settings
JAVA_OPTS="-Xms4G -Xmx8G" gatling.sh -s StressTest

Cas d’Utilisation 3 : Intégration CI/CD avec Maven

# Add to Jenkins/GitLab CI pipeline
mvn clean gatling:test \
  -Dgatling.simulationClass=com.example.PerformanceTest \
  -DbaseUrl=${TEST_URL} \
  -Dusers=${CONCURRENT_USERS} \
  -Dduration=${TEST_DURATION}

# Check exit code for pass/fail
if [ $? -eq 0 ]; then
  echo "Performance test passed"
else
  echo "Performance test failed"
  exit 1
fi

# Archive results
tar -czf gatling-results.tar.gz target/gatling/

Cas d’Utilisation 4 : Enregistrement de Session de Navigateur

# Start recorder
recorder.sh

# Configure in GUI:
# - Listening Port: 8000
# - Output folder: user-files/simulations
# - Class name: RecordedSimulation

# Configure browser proxy to localhost:8000
# Perform actions in browser
# Stop recording

# Run recorded simulation
gatling.sh -s RecordedSimulation

Cas d’Utilisation 5 : Test Piloté par les Données avec Feeders

# Create CSV data file
cat > user-files/resources/users.csv << 'EOF'
username,password
user1,pass1
user2,pass2
user3,pass3
EOF

# Create simulation with feeder
cat > user-files/simulations/DataDrivenTest.scala << 'EOF'
import io.gatling.core.Predef._
import io.gatling.http.Predef._

class DataDrivenTest extends Simulation {
  val httpProtocol = http.baseUrl("https://api.example.com")
  
  val feeder = csv("users.csv").circular

  val scn = scenario("Login Test")
    .feed(feeder)
    .exec(http("Login")
      .post("/login")
      .body(StringBody("""{"username":"${username}","password":"${password}"}"""))
      .check(status.is(200)))

  setUp(scn.inject(atOnceUsers(10))).protocols(httpProtocol)
}
EOF

# Run test
gatling.sh -s DataDrivenTest

Meilleures Pratiques

  • Utiliser des Profils de Charge Appropriés : Commencez par une montée en charge progressive (rampUsers) plutôt que atOnceUserspour simuler des modèles de trafic réalistes et éviter de surcharger immédiatement le système

  • Définir des Délais d’Attente Réalistes : Configurez les délais de connexion et de requête en fonction de vos SLA (par exemple,requestTimeout = 30000pendant 30 secondes) pour détecter précocement les problèmes de performance

  • Implémenter des Assertions Appropriées : Ajouter des assertions pour faire échouer automatiquement les tests lorsque les performances se dégradent (global.responseTime.percentile3.lt(2000)garantit le 95e percentile sous 2 secondes)

  • Utiliser des Feeders pour des Données Dynamiques : Exploiter CSV, JSON, ou des feeders personnalisés au lieu de coder en dur les données de test pour simuler le comportement réel des utilisateurs et éviter les hits de cache

  • Allouer Suffisamment de Mémoire : Pour les tests à grande échelle, augmenter la taille du tas JVM (-Xms4G -Xmx8G) pour éviter les erreurs OutOfMemory et assurer une exécution fluide

  • Surveiller les Ressources Système : Suivre l’utilisation du CPU, de la mémoire et du réseau sur le générateur de charge et le système cible pendant les tests pour identifier précisément les goulots d’étranglement

  • Exécuter les Tests depuis un Environnement Similaire à la Production : Effectuer des tests de charge depuis une infrastructure similaire à la production (latence réseau, bande passante) pour des résultats précis

  • Contrôler les Versions de vos Simulations : Stocker le code de simulation dans Git à côté du code d’application pour suivre les modifications et permettre la collaboration

  • Séparer les Préoccupations avec des Scénarios : Décomposer les tests complexes en plusieurs scénarios et chaînes pour une meilleure maintenabilité et réutilisabilité

  • Analyser Minutieusement les Rapports : Ne pas se contenter de vérifier les temps de réponse — examiner la distribution des requêtes, les taux d’erreur et les percentiles de temps de réponse pour comprendre l’image complète des performances

Dépannage

ProblèmeSolution
OutOfMemoryError during test executionIncrease JVM heap size: JAVA_OPTS="-Xms4G -Xmx8G" gatling.sh -s MySimulation or reduce concurrent users
”Simulation class not found” errorEnsure simulation is in user-files/simulations/ and class name matches file name. Recompile if needed: mvn clean compile
Connection timeout errorsIncrease timeout in gatling.conf: gatling.http.connectTimeout = 30000 or check network connectivity to target system
SSL/TLS certificate errorsDisable certificate validation in simulation: .disableCaching.disableWarmUp.shareConnections.silentResources or add certificate to Java keystore
Recorder proxy not workingVérifiez les paramètres de proxy du navigateur (localhost:8000), assurez-vous que l’enregistreur est en cours d’exécution, vérifiez qu’aucun autre proxy/VPN n’interfère
Reports not generatingVérifier l’espace disque, vérifier les permissions d’écriture sur le répertoire des résultats, s’assurer que le test s’est terminé avec succès sans plantages
High response times on load generatorLe load generator est surchargé—réduire les utilisateurs concurrents, augmenter les ressources, ou utiliser des tests distribués avec plusieurs générateurs
”Too many open files” error (Linux)Increase file descriptor limit: ulimit -n 65536 before running Gatling, or add to /etc/security/limits.conf
Simulations compile but don’t runVérifier les erreurs de syntaxe dans le code Scala, vérifier que tous les imports sont corrects, s’assurer de la compatibilité de la version de Gatling
Maven/Gradle plugin not foundUpdate plugin version in pom.xml/build.gradle, run mvn clean install or gradle clean build, check Maven Central connectivity
Inconsistent results between runsPréchauffer le système cible en premier, assurer un environnement de test cohérent, vérifier les facteurs externes (autre trafic, tâches programmées)
WebSocket connection failuresVerify WebSocket protocol in simulation: .ws("Connect").connect("/socket"), check target server WebSocket support
Feeder file not foundPlace CSV/JSON files in user-files/resources/, use relative path: csv("data.csv") not absolute path
Docker container exits immediatelyMount volumes correctly: -v $(pwd)/user-files:/opt/gatling/user-files, ensure simulation files exist in mounted directory

Référence Rapide : Profils d’Injection de Charge

// Immediate load
atOnceUsers(100)

// Gradual ramp-up
rampUsers(100) during (60 seconds)

// Constant rate
constantUsersPerSec(20) during (5 minutes)

// Gradual rate increase
rampUsersPerSec(10) to 50 during (2 minutes)

// Staircase pattern
incrementUsersPerSec(5)
  .times(5)
  .eachLevelLasting(30 seconds)
  .separatedByRampsLasting(10 seconds)
  .startingFrom(10)

// Complex scenario
nothingFor(5 seconds),
atOnceUsers(10),
rampUsers(50) during (30 seconds),
constantUsersPerSec(20) during (60 seconds)

Emplacements de Fichiers Utiles

CheminDescription
user-files/simulations/Fichiers Scala de simulation
user-files/resources/Fichiers de données Feeder (CSV, JSON)
user-files/bodies/Modèles de corps de requête
results/Rapports HTML générés
conf/gatling.confFichier de configuration principal
conf/logback.xmlConfiguration de logging
target/gatling/Sortie de build Maven et rapports