Private datacenter (Outpost) test

Problem: Your target service is not reachable from the public internet. It lives behind a VPN, in a private subnet, or in a regulated environment, and MaxoPerf’s managed cloud locations cannot reach it. A BYOC Outpost (Bring Your Own Compute) installs a MaxoPerf runner agent inside your network. Tests run from there, and the results show up in the same MaxoPerf console.

Test type: Any (Load test, Stress test, Smoke test).

Prerequisites

• A MaxoPerf workspace with permission to create private datacenters.
• A Docker host or a Kubernetes cluster inside the target network with outbound HTTPS access to MaxoPerf service endpoints.
• A test file targeting an internal URL.

See Connect a private datacenter for the full installation how-to.

Step by step in MaxoPerf

1. Register the private datacenter

1. Open the Workspace page and switch to the Private datacenters tab.
2. Click New private datacenter.
3. Give it a descriptive name, for example k8s-staging-internal or aws-vpc-us-east.
4. Choose the runtime (Docker or Kubernetes) and save.
5. Copy the generated install snippet. It contains a one-time enrollment token and the MaxoPerf service endpoints.

2. Install the Outpost agent

1. SSH into your Docker host (or apply the Kubernetes manifests to your cluster).
2. Run the install snippet. The agent registers, exchanges the one-time token for a long-lived identity, and appears as running in the console within 30–60 seconds.

Treat the enrollment token as a secret

The token is single-use and short-lived, but anyone with it can register an agent against your workspace before it expires. Never paste it into shared channels or commit it to a repository.

3. Write a test targeting the internal URL

execution:
  - scenario: internal-api
    concurrency: 20
    ramp-up: 2m
    hold-for: 5m

scenarios:
  internal-api:
    requests:
      - label: GET /internal/health
        url: http://internal-api.svc.cluster.local:8080/internal/health
        method: GET

      - label: POST /internal/jobs
        url: http://internal-api.svc.cluster.local:8080/internal/jobs
        method: POST
        headers:
          Content-Type: application/json
          Authorization: Bearer ${INTERNAL_API_TOKEN}
        body: '{"type": "load-test-job", "payload": {}}'

The internal hostname resolves inside your network but not from outside. That is why you need the Outpost.

4. Configure the test to use the private location

1. Upload the YAML under Files and bind INTERNAL_API_TOKEN under Settings → Secrets.
2. Switch to the Configuration tab.
3. Under Locations, remove any managed cloud locations and add your private datacenter location.
4. Save and click Run now.

5. Verify the runners are in the private location

1. Open the run and switch to the Runners tab.
2. Each runner should display your private datacenter name as its location badge.
3. If runners show a managed cloud region instead, check that the private location is the only selected location in the Configuration tab.

Verify

• The Runners tab shows runners from your private datacenter (not a managed cloud region).
• The internal URL responds with 2xx on the health and action labels.
• Latency is lower than it would be from a managed public cloud region because the runner is co-located with the target.
• If latency is unexpectedly high, check the network path between the runner host and the target service.

Variations

• Mix private + cloud: give 80 % to the private location and 20 % to a cloud region to test the internal path and internet-facing routing at the same time.
• Multiple Outpost agents: register a second private datacenter in a different private subnet to test east–west latency inside your network.
• Docker Compose quick start: for a quick smoke test, the Docker runtime needs only a single docker run command. No Kubernetes required.

Where to go next

• Connect a private datacenter: the full Outpost installation and configuration reference.
• Multi-region distributed load: combine Outpost with managed cloud locations.
• Managed and private load locations: when each kind of location fits best.