Node Targeting Documentation

Matching docs

Search across docs titles, summaries, groups, and section headings.

Use Up and Down Arrow to move through results, then press Enter to open the active page.

What this page helps you do

Node targeting decides which scenarios stay on the coordinator and which are pushed to agents in clustered runs.

Who this is for

Teams moving from one machine to coordinator-and-agent execution or tighter workload targeting.

Prerequisites

A scenario that already works in a single-node run

By the end

A clearer cluster topology and the fields that must line up across nodes.

Read cluster overview Compare plans

Use this page when

Use this page when execution topology, partitioning, or targeting changes how the run should be distributed.

Visual guide

Node targeting flow showing filters routing scenarios to coordinator and agents. — Node targeting filters route scenario ownership to the coordinator, agents, or the whole cluster.

Guide

What node targeting solves

Node targeting lets you run only the scenarios that belong on a given role or node group. This is useful when one set of nodes should publish traffic and another should consume or observe downstream activity.

Available target lists

Use TargetScenarios for a global filter. AgentTargetScenarios and CoordinatorTargetScenarios provide role-specific filters only where the selected SDK and engine support them. Go V1 applies the agent list but not the coordinator list, and Go V2 rejects both role-specific lists. The runtime compares exact registered scenario names.

When to keep it simple

If every node can run every scenario, skip targeting and let the coordinator distribute the workload normally. Add targeting only when you need explicit workload ownership.

Cluster setup samples

The C# sample below shows a distributed role split. The Go tab uses local coordinator-managed children: V1 supports AgentTargetScenarios but does not apply CoordinatorTargetScenarios, while V2 rejects both role-specific lists.

If you run these examples locally, add a valid runner key before execution starts. Set it with WithRunnerKey("...") or the config key LoadStrike:RunnerKey.

Target Scenarios Per Node

using LoadStrike;

var clusterId = "orders-cluster";
var natsUrl = "nats://nats.example.internal:4222";

var publishOrdersScenario = LoadStrikeScenario.Create(
        "publish-orders",
        _ => Task.FromResult(LoadStrikeResponse.Ok(statusCode: "202")))
    .WithLoadSimulations(LoadStrikeSimulation.IterationsForConstant(1, 2));

var observeCompletionScenario = LoadStrikeScenario.Create(
        "observe-completion",
        _ => Task.FromResult(LoadStrikeResponse.Ok(statusCode: "200")))
    .WithLoadSimulations(LoadStrikeSimulation.IterationsForConstant(1, 2));

var agentContext = LoadStrikeRunner
    .RegisterScenarios(publishOrdersScenario, observeCompletionScenario)
    .WithNodeType(LoadStrikeNodeType.Agent)
    .WithClusterId(clusterId)
    .WithAgentTargetScenarios("observe-completion")
    .WithNatsServerUrl(natsUrl);

// Each agent process listens for the scenario names assigned to agents.
agentContext.Run();

var coordinatorContext = LoadStrikeRunner
    .RegisterScenarios(publishOrdersScenario, observeCompletionScenario)
    .WithNodeType(LoadStrikeNodeType.Coordinator)
    .WithClusterId(clusterId)
    .WithAgentsCount(2)
    .WithCoordinatorTargetScenarios("publish-orders")
    .WithAgentTargetScenarios("observe-completion")
    .WithNatsServerUrl(natsUrl)
    .WithRunnerKey("rkr_your_remote_runner_key");

// The coordinator triggers only its own scenarios and routes agent work by scenario name.
coordinatorContext.Run();

package main

import loadstrike "loadstrike.com/sdk/go"

func main() {
    source := loadstrike.Empty("source")
    destination := loadstrike.Empty("destination")

    // V1 supports agent-specific targeting in local coordinator mode.
    // CoordinatorTargetScenarios is not applied by the current Go release.
    loadstrike.RegisterScenarios(source, destination).
        WithRunnerKey("rkl_your_local_runner_key").
        WithClusterId("cluster-orders-local").
        WithNatsServerUrl("nats://127.0.0.1:4222"). // Start NATS locally first.
        WithNodeType(loadstrike.NodeTypeCoordinator).
        WithAgentsCount(2).
        EnableLocalDevCluster(true).
        WithTargetScenarios("source", "destination").
        WithAgentTargetScenarios("destination").
        Run()
}

import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeResponse;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeNodeType;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeRunner;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeScenario;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeSimulation;

String clusterId = "orders-cluster";
String natsUrl = "nats://nats.example.internal:4222";

var publishOrdersScenario = LoadStrikeScenario
    .create("publish-orders", ignoredContext -> LoadStrikeResponse.ok("202"))
    .withLoadSimulations(LoadStrikeSimulation.iterationsForConstant(1, 2));

var observeCompletionScenario = LoadStrikeScenario
    .create("observe-completion", ignoredContext -> LoadStrikeResponse.ok("200"))
    .withLoadSimulations(LoadStrikeSimulation.iterationsForConstant(1, 2));

var agentRunner = LoadStrikeRunner
    .registerScenarios(publishOrdersScenario, observeCompletionScenario)
    .withNodeType(LoadStrikeNodeType.Agent)
    .buildContext()
    .withClusterId(clusterId)
    .withAgentTargetScenarios("observe-completion")
    .withNatsServerUrl(natsUrl);

// Each agent process listens for the scenario names assigned to agents.
agentRunner.run();

var coordinatorRunner = LoadStrikeRunner
    .registerScenarios(publishOrdersScenario, observeCompletionScenario)
    .withNodeType(LoadStrikeNodeType.Coordinator)
    .buildContext()
    .withClusterId(clusterId)
    .withAgentsCount(2)
    .withCoordinatorTargetScenarios("publish-orders")
    .withAgentTargetScenarios("observe-completion")
    .withNatsServerUrl(natsUrl)
    .withRunnerKey("rkr_your_remote_runner_key");

// The coordinator triggers only its own scenarios and routes agent work by scenario name.
coordinatorRunner.run();

from loadstrike_sdk import LoadStrikeResponse, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeSimulation

cluster_id = "orders-cluster"
nats_url = "nats://nats.example.internal:4222"

publish_orders_scenario = (
    LoadStrikeScenario.create("publish-orders", lambda _: LoadStrikeResponse.ok("202"))
    .with_load_simulations(LoadStrikeSimulation.iterations_for_constant(1, 2))
)

observe_completion_scenario = (
    LoadStrikeScenario.create("observe-completion", lambda _: LoadStrikeResponse.ok("200"))
    .with_load_simulations(LoadStrikeSimulation.iterations_for_constant(1, 2))
)

agent_runner = (
    LoadStrikeRunner.register_scenarios(publish_orders_scenario, observe_completion_scenario)
    .with_node_type("Agent")
    .with_cluster_id(cluster_id)
    .with_agent_target_scenarios("observe-completion")
    .with_nats_server_url(nats_url)
)

# Each agent process listens for the scenario names assigned to agents.
agent_runner.run()

coordinator_runner = (
    LoadStrikeRunner.register_scenarios(publish_orders_scenario, observe_completion_scenario)
    .with_node_type("Coordinator")
    .with_cluster_id(cluster_id)
    .with_agents_count(2)
    .with_coordinator_target_scenarios("publish-orders")
    .with_agent_target_scenarios("observe-completion")
    .with_nats_server_url(nats_url)
    .with_runner_key("rkr_your_remote_runner_key")
)

# The coordinator triggers only its own scenarios and routes agent work by scenario name.
coordinator_runner.run()

import {
  LoadStrikeResponse,
  LoadStrikeRunner,
  LoadStrikeScenario,
  LoadStrikeSimulation
} from "@loadstrike/loadstrike-sdk";

const clusterId = "orders-cluster";
const natsUrl = "nats://nats.example.internal:4222";

const publishOrdersScenario = LoadStrikeScenario
  .create("publish-orders", async () => LoadStrikeResponse.ok("202"))
  .withLoadSimulations(LoadStrikeSimulation.iterationsForConstant(1, 2));

const observeCompletionScenario = LoadStrikeScenario
  .create("observe-completion", async () => LoadStrikeResponse.ok("200"))
  .withLoadSimulations(LoadStrikeSimulation.iterationsForConstant(1, 2));

const agentRunner = LoadStrikeRunner
  .registerScenarios(publishOrdersScenario, observeCompletionScenario)
  .withNodeType("Agent")
  .withClusterId(clusterId)
  .withAgentTargetScenarios("observe-completion")
  .withNatsServerUrl(natsUrl);

// Each agent process listens for the scenario names assigned to agents.
await agentRunner.run();

const coordinatorRunner = LoadStrikeRunner
  .registerScenarios(publishOrdersScenario, observeCompletionScenario)
  .withNodeType("Coordinator")
  .withClusterId(clusterId)
  .withAgentsCount(2)
  .withCoordinatorTargetScenarios("publish-orders")
  .withAgentTargetScenarios("observe-completion")
  .withNatsServerUrl(natsUrl)
  .withRunnerKey("rkr_your_remote_runner_key");

// The coordinator triggers only its own scenarios and routes agent work by scenario name.
await coordinatorRunner.run();

const {
  LoadStrikeResponse,
  LoadStrikeRunner,
  LoadStrikeScenario,
  LoadStrikeSimulation
} = require("@loadstrike/loadstrike-sdk");

(async () => {
  const clusterId = "orders-cluster";
  const natsUrl = "nats://nats.example.internal:4222";

  const publishOrdersScenario = LoadStrikeScenario
    .create("publish-orders", async () => LoadStrikeResponse.ok("202"))
    .withLoadSimulations(LoadStrikeSimulation.iterationsForConstant(1, 2));

  const observeCompletionScenario = LoadStrikeScenario
    .create("observe-completion", async () => LoadStrikeResponse.ok("200"))
    .withLoadSimulations(LoadStrikeSimulation.iterationsForConstant(1, 2));

  const agentRunner = LoadStrikeRunner
    .registerScenarios(publishOrdersScenario, observeCompletionScenario)
    .withNodeType("Agent")
    .withClusterId(clusterId)
    .withAgentTargetScenarios("observe-completion")
    .withNatsServerUrl(natsUrl);

  // Each agent process listens for the scenario names assigned to agents.
  await agentRunner.run();

  const coordinatorRunner = LoadStrikeRunner
    .registerScenarios(publishOrdersScenario, observeCompletionScenario)
    .withNodeType("Coordinator")
    .withClusterId(clusterId)
    .withAgentsCount(2)
    .withCoordinatorTargetScenarios("publish-orders")
    .withAgentTargetScenarios("observe-completion")
    .withNatsServerUrl(natsUrl)
    .withRunnerKey("rkr_your_remote_runner_key");

  // The coordinator triggers only its own scenarios and routes agent work by scenario name.
  await coordinatorRunner.run();
})();

Node targeting fields

WithTargetScenarios(names)

Applies a global scenario-name filter to the current run context.

WithAgentTargetScenarios(names)

Applies an additional agent-side filter where supported. Go applies it only in V1; Go V2 rejects it.

WithCoordinatorTargetScenarios(names)

Applies an additional coordinator-side filter where supported. Go V1 accepts but does not apply it, and Go V2 rejects it.

Scenario names

Filters are matched against the registered scenario names, so they must use the exact names defined in code.

Matching docs

What this page helps you do

What this page helps you do

Who this is for

Prerequisites

By the end

Use this page when

Visual guide

Guide

What node targeting solves

Available target lists

When to keep it simple

Cluster setup samples

Target Scenarios Per Node

Node targeting fields

Related category and article pages

Distributed load testing

Self-hosted load testing

Benchmark methodology