JMeter and Gatling (and When to Use Which Tool)

1. 1

   Run a JMeter plan headless

   A minimal plan (build it in the GUI once, then commit the .jmx). -J passes properties so the same plan runs against any environment and load level.

   <ThreadGroup testname="Shoppers">
     <stringProp name="ThreadGroup.num_threads">${__P(users,50)}</stringProp>
     <stringProp name="ThreadGroup.ramp_time">${__P(rampup,60)}</stringProp>
     <boolProp name="ThreadGroup.scheduler">true</boolProp>
     <stringProp name="ThreadGroup.duration">${__P(duration,300)}</stringProp>
   </ThreadGroup>
   <hashTree>
     <CSVDataSet testname="Users CSV"><stringProp name="filename">users.csv</stringProp></CSVDataSet>
     <HTTPSamplerProxy testname="GET /products">
       <stringProp name="HTTPSampler.domain">${__P(host,localhost)}</stringProp>
       <stringProp name="HTTPSampler.path">/api/products?q=${query}</stringProp>
     </HTTPSamplerProxy>
     <UniformRandomTimer testname="Think time"><stringProp name="RandomTimer.range">2000</stringProp></UniformRandomTimer>
   </hashTree>

   terminalcopy cmd

   $ jmeter -n -t checkout.jmx -Jhost=staging.shoplite.dev -Jusers=200 -Jduration=600 -l results.jtl -e -o report/

   grep -A1 'summary =' jmeter.log | tail -2

   ── expected output ──

   summary = 184233 in 00:10:00 = 307.1/s Avg: 188 Min: 12 Max: 4102 Err: 611 (0.33%)

   Tidying up ... @ Sat Sep 27 11:42:10 IST 2026

2. 2

   The same journey in Gatling (Java DSL)

   An open-model ramp with assertions. Run with the Maven/Gradle plugin; the build fails if assertions fail.

   package shoplite;
   
   import static io.gatling.javaapi.core.CoreDsl.*;
   import static io.gatling.javaapi.http.HttpDsl.*;
   import io.gatling.javaapi.core.*;
   import io.gatling.javaapi.http.*;
   import java.time.Duration;
   
   public class CheckoutSimulation extends Simulation {
     HttpProtocolBuilder http = http.baseUrl(System.getProperty("baseUrl", "http://localhost:8080"))
         .acceptHeader("application/json");
   
     FeederBuilder<String> users = csv("users.csv").random();
   
     ScenarioBuilder shop = scenario("Browse and checkout")
         .feed(users)
         .exec(http("search").get("/api/products?q=#{query}").check(status().is(200)))
         .pause(Duration.ofSeconds(1), Duration.ofSeconds(3))
         .exec(http("add to cart").post("/api/cart").body(StringBody("{\"sku\":\"MUG-RED\"}")).asJson())
         .exec(http("checkout").post("/api/checkout").check(status().in(200, 201)));
   
     {
       setUp(shop.injectOpen(
               rampUsersPerSec(5).to(150).during(Duration.ofMinutes(3)),
               constantUsersPerSec(150).during(Duration.ofMinutes(5))))
           .protocols(http)
           .assertions(
               global().responseTime().percentile(95.0).lt(400),
               global().failedRequests().percent().lt(1.0));
     }
   }

   terminalcopy cmd

   $ ./mvnw gatling:test -Dgatling.simulationClass=shoplite.CheckoutSimulation -DbaseUrl=https://staging.shoplite.dev

   ── expected output ──

   ---- Global Information --------------------------------------------------------

   > request count 91520 (OK=91204 KO=316 )

   > response time 95th percentile (ms) 361 (OK=355 KO=5001 )

   > mean requests/sec 190.6 (OK=190 KO=0.66 )

   Global: 95th percentile of response time is less than 400 : true

   Global: percentage of failed events is less than 1.0 : true

3. 3

   Distributed k6 on Kubernetes

   The k6 Operator runs a script as N parallel pods and splits the load between them. parallelism: 4 quadruples generator capacity.

   apiVersion: k6.io/v1alpha1
   kind: TestRun
   metadata:
     name: black-friday-rehearsal
   spec:
     parallelism: 4
     script:
       configMap: { name: loadtest, file: loadtest.js }
     arguments: -e BASE_URL=https://staging.shoplite.dev

Each drill is a real failure mode. Read the scenario and the output, decide what's wrong, then reveal the diagnosis.