Getting Started

Relampo CLI

Usage guide and command reference

Relampo CLI is the command-line tool to create, refine, and execute performance tests using YAML scripts.

The typical flow starts from real traffic or existing collections, transforms them into an executable YAML script, and takes the script to local or distributed execution.

What you can do with the CLI

With Relampo CLI you can:

• generate YAML scripts from real traffic or collections
• detect and apply dynamic correlation automatically
• edit and maintain scripts from the visual editor
• debug test flows before load execution
• run load tests locally
• scale executions with distributed mode

Typical workflow

The usual workflow with Relampo CLI is:

relampo record / relampo converter -> relampo correlate -> relampo correlate --apply -> relampo editor -> relampo debug -> relampo run -> relampo distributed run

This flow lets you go from real traffic or existing collections to a stable script that can run locally or in distributed mode.

Activity workflow

Quick operational view:

+---------------------------------------+
| 1) Capture / Convert base             |
+---------------------------------------+
                  |
                  v
+---------------------------------------+
| 2) Correlation analysis               |
+---------------------------------------+
                  |
                  v
+---------------------------------------+
| 3) Apply correlation                  |
+---------------------------------------+
                  |
                  v
+---------------------------------------+
| 4) Script editing                     |
+---------------------------------------+
                  |
                  v
+---------------------------------------+
| 5) Debug flow                         |
+---------------------------------------+
                  |
                  v
+---------------------------------------+
| 6) Local run                          |
+---------------------------------------+
                  |
                  v
+---------------------------------------+
| 7) Distributed run                    |
+---------------------------------------+

Workflow stages:

1. Capture or convert a base using relampo record --port 8888 --responses --output my-test.yaml or relampo converter.
2. Analyze correlation with relampo correlate my-test.yaml.
3. Apply correlation with relampo correlate my-test.yaml --apply.
4. Refine the script with relampo editor.
5. Verify behavior with relampo debug my-test.yaml.correlated.yaml.
6. Run local load with relampo run my-test.yaml.correlated.yaml.
7. Scale across multiple nodes with relampo distributed run /path/test.yaml --repo owner/perf-tests --nodes 2 --vus 10 --duration 2m.

Step-by-step command reference

1. Verify installation

Before starting, confirm the CLI is installed and available in your environment.

relampo --help

2. Generate a base YAML script

You can generate an initial script in two ways: capture HTTP traffic in real time or convert an existing collection.

Capture traffic:

relampo record --port 8888 --responses --output my-test.yaml

This command captures HTTP/HTTPS traffic and intercepts requests in real time.

Recording continues until you stop it manually (for example with Ctrl+C). At the end, Relampo generates a YAML script with requests and responses from the session.

Convert a collection:

relampo converter

relampo converter opens the Relampo converter in the browser. From there you can review detected requests and generate the YAML script for your test.

3. Analyze dynamic correlation

Some responses contain dynamic values (such as tokens or IDs) that must be reused in later requests.

You can analyze the script to detect correlation candidates:

relampo correlate my-test.yaml

This command identifies correlation candidates in the script.

4. Apply correlations

Once correlations are detected, you can apply them automatically:

relampo correlate my-test.yaml --apply

This generates a script version with extractors and references so the flow behaves correctly under load.

5. Edit the script

You can adjust the YAML script using the Relampo visual editor.

relampo editor

Open relampo editor, load the YAML, and edit it visually. Changes are saved in the YAML file.

From the editor you can:

• modify requests and parameters
• adjust global variables
• reorganize scenario flow
• edit assertions and extractors

6. Debug the test

Before running a load test, validate flow behavior with debug mode:

relampo debug my-test.yaml.correlated.yaml

Debug mode lets you:

• inspect requests and responses
• review flow variables step by step
• verify dynamic correlations
• confirm the scenario runs without errors

7. Run the test

Once the flow is validated, run the load test.

relampo run my-test.yaml.correlated.yaml

Relampo processes the script and executes the scenario with the user and load configuration defined in YAML.

Distributed execution

When you need to scale across multiple nodes, use distributed mode.

Prepare environment:

relampo distributed setup --repo owner/perf-tests

Upload scripts and data files:

relampo distributed files upload \
  --repo owner/perf-tests \
  --files "[/path/test.yaml,/path/users.csv]"

Windows tip

On Windows, replace \ with PowerShell backtick (`) or CMD caret (^). You can also run this command in a single line.

Note: --files expects a comma-separated list of paths inside brackets and quotes.

Run distributed test:

relampo distributed run /path/test.yaml \
  --repo owner/perf-tests \
  --nodes 2 \
  --vus 10 \
  --duration 2m

Windows tip

On Windows, replace \ with PowerShell backtick (`) or CMD caret (^). You can also run this command in a single line.

This runs the test across multiple nodes and aggregates results.

Quick reference

Summary of workflow commands:

Step	Command	What it does
Capture traffic	relampo record --port 8888 --responses --output my-test.yaml	Generate YAML script with requests and responses from real HTTP traffic
Convert collection	relampo converter	Generate YAML from an existing collection
Detect correlations	relampo correlate	Analyze dynamic values in the script
Apply correlations	relampo correlate --apply	Insert extractors automatically
Edit	relampo editor	Refine the script in the visual editor
Debug	relampo debug	Validate behavior before load execution
Run	relampo run	Execute the load test locally
Distributed	relampo distributed run	Scale execution across multiple nodes