We don't use dedicated hardware for this. We run one central TR-143 test
target that all our TAUC routers test against.

WHAT WE RUN
- Plain nginx in a Docker container on an existing Linux VM in our
datacenter
- It sits on a segment our customer routers can reach directly, so there's
no public IP, port forward or tunnel
- Plain HTTP, no TLS
- It's been up since May with no maintenance, using about 23 MB of RAM and
no measurable CPU
- Thousands of completed tests since then, with only a handful of failed
uploads

WHAT THE SERVER HAS TO DO
With TR-143 the router does the measuring. The server only has to:
- Download leg: GET /downloads/100MB.file returns 200 plus the file, with
an exact Content-Length
- Upload leg: PUT /uploads/upload.file returns 201 on the first upload and
204 after that, once the whole body has arrived
- Ping: answered by the host OS, not the container
- Anything else returns 403

THE SETUP
Two small config files and a folder of test files. Everything is mounted
read-only except the upload folder, which is a size-capped RAM disk.

docker-compose.yml:

services:
  tauc-speedtest:
    image: nginx:latest
    container_name: tauc-speedtest
    restart: unless-stopped
    ports:
      - "80:80"
    volumes:
      - ./download-files:/usr/share/nginx/html/downloads:ro
      - ./site-config:/etc/nginx/conf.d:ro
    tmpfs:
      # RAM-backed sink for uploads. Capped so a runaway upload
      # can't use up host RAM. Clears on container restart.
      - /usr/share/nginx/html/uploads:size=2g,mode=1777

site-config/default.conf:

# Log request_length so upload tests show the bytes actually received
# (the default log format only records the response size).
log_format  speedtest '$remote_addr - $remote_user [$time_local] '
                      '"$request" $status req_len=$request_length '
                      'content_length=$content_length '
                      'expect="$http_expect" '
                      'body_bytes_sent=$body_bytes_sent '
                      'rt=$request_time ua="$http_user_agent"';

server {
    listen      80 default_server;
    server_name _;

    access_log  /var/log/nginx/access.log speedtest;
    root        /usr/share/nginx/html;

    # Download leg: GET only, static files
    location /downloads {
        limit_except GET { deny all; }
    }

    # Upload leg: WebDAV PUT, so nginx reads the ENTIRE body
    # before it replies. Files land on the tmpfs RAM disk.
    location /uploads/ {
        dav_methods            PUT;
        client_max_body_size   2G;
        create_full_put_path   on;
        dav_access             user:rw group:rw all:r;
    }

    # Everything else denied
    location / {
        deny all;
    }
}

Create the test files and start it (random bytes, so nothing in the path
can compress them):

mkdir -p download-files site-config
dd if=/dev/urandom of=download-files/20MB.file  bs=1M count=20   status=none
dd if=/dev/urandom of=download-files/100MB.file bs=1M count=100  status=none
dd if=/dev/urandom of=download-files/500MB.file bs=1M count=500  status=none
dd if=/dev/urandom of=download-files/1GB.file   bs=1M count=1024 status=none
docker compose up -d

Smoke test:

curl -I http://<server IP>/downloads/20MB.file             (expect 200,
Content-Length: 20971520)
curl -T /etc/hostname -i http://<server IP>/uploads/t.file (expect 201 the
first time, 204 after)
curl -I http://<server IP>/                                (expect 403)
ping -c 4 <server IP>

New file sizes show up as soon as you drop them into download-files/.
Config changes need "docker compose restart".

TAUC PROFILE
In TAUC: System Settings > Profile Management > Speed Tier Profile > Add.
- Test Method: TR-143
- IP Version: IPv4
- Upload and Download: both enabled
- Speed Test Server: <server IP>
- Download URL: http://<server IP>/downloads/100MB.file
- Upload URL: http://<server IP>/uploads/upload.file
- Internet Ping Server: <server IP>
- Account and Password: blank

We use the 100 MB file for every tier. Pick a size that takes several
seconds at your plan speeds. With small files, TCP ramp-up takes up too
much of the test and skews the result.

LESSONS
- Use WebDAV PUT for uploads, not "return 204". Stock nginx answers PUT
with a 405, and some TR-143 clients count any non-2xx as a failed test. The
common fix is "return 204", but nginx can send that reply before the upload
has finished arriving. With dav_methods PUT, nginx reads the whole body
first and then replies.
- Generate your own test files. Use random bytes from /dev/urandom, not a
binary shipped in someone's repo. A compressible file lets anything in the
path inflate the result.
- Plain HTTP, no proxy, no tunnel. TLS adds CPU work to every test. A
Cloudflare tunnel or reverse proxy caps and distorts throughput.
- Lock it down anyway. Only /downloads (GET) and /uploads (PUT) are open;
everything else returns 403. Config and files are mounted read-only. At
deploy we packet-captured the container and saw nothing leave it except
replies to the device running the test.
- Pin the image. We run nginx:latest. Pinning a version is the tidier
choice.

FOR PER-SITE BOXES
We haven't done this ourselves; our single central target covers our
footprint. How we'd approach it:
- The network port is the spec that matters. The server load is trivial,
but the box's port has to be faster than your fastest plan, or you end up
measuring the box. 1 GbE tops out around 940 Mbps of TCP throughput, so gig
plans need 2.5 GbE or faster. Our plans are well under a gig, so we haven't
load-tested at those rates.
- Size the RAM disk to the box. Our 2 GB upload cap assumes a host with RAM
to spare. On a small box, shrink it to cover your largest upload plus some
headroom.
- Placement decides what gets measured. A box at the tower measures that
site's access link only. A central box also includes your backhaul. Both
stay on your own network, so neither includes transit.
- One profile per server. The server address is set in the Speed Tier
Profile, so each site's target needs its own profile, and each router has
to stay on the right one.
- The compose file and nginx config above run unchanged on any small Linux
machine with Docker.

CREDIT
Based on roadrunnerspeed/tauc-speedtest on GitHub (MIT licensed). Our
changes: WebDAV PUT into a RAM disk for uploads, our own random test files,
a catch-all server_name, read-only mounts, and a 2 GB upload limit.

On Wed, Oct 28, 2026 at 9:35 AM Jason McKemie <
[email protected]> wrote:

> For those of you using TP-Link routers / TAUC, what are you using for
> basic speedtest server hardware?  I'm looking to deploy something at
> individual sites, so a small, bare-metal setup would be best.
> --
> AF mailing list
> [email protected]
> http://af.afmug.com/mailman/listinfo/af_af.afmug.com
>
-- 
AF mailing list
[email protected]
http://af.afmug.com/mailman/listinfo/af_af.afmug.com

Reply via email to