Tutorials

Three gentle walks for a Linux user who knows mounts and is learning ports. The To-Go Box stays tiny. The folder you mount — and companions beside it — do the rest.

Official image: ghcr.io/crimsonflower420/krazytogo:latest. Tiny. Non-root. No shell, no package manager. The folder you mount is the share. Extra tools sit beside the box, not inside it.

Take Jellyfin media files to go

You already run Jellyfin (or Immich / Audiobookshelf) against a media folder. Mount that same folder into the Krazy To-Go Box as a companion container. Jellyfin keeps its own port; the box gets a second port with a plain file listing you can open in a browser.

Same To-Go Box image on Docker, Podman, and Kubernetes — you choose the container program. Only the way the folder is attached changes. This walk mounts the same media folder into Jellyfin and the To-Go Box so you can list and download files on a second port.

Idea: one folder on disk, two containers. Jellyfin uses it for playback. The To-Go Box uses it for a simple listing + downloads on another port.

1. Pick a picture you own and copy it into the media folder (or a data/ folder you will mount).

Copy a JPG into the share
mkdir -p data
cp ~/Pictures/lake.jpg data/lake.jpg

Windows PowerShell: New-Item -ItemType Directory -Force data; Copy-Item $env:USERPROFILE\Pictures\lake.jpg data\lake.jpg

2. Start the official To-Go Box. Map host port 8080 (or another free port) to the box’s 8080. Mount the folder at /data.

Docker — run the companion box
docker pull ghcr.io/crimsonflower420/krazytogo:latest
docker run -d --name krazy \
  -p 8080:8080 \
  -v "$PWD/data:/data" \
  -e KRAZY_ROOT=/data \
  -e KRAZY_BROWSE=true \
  ghcr.io/crimsonflower420/krazytogo:latest

If Jellyfin already mounts e.g. /srv/media, use that path instead of $PWD/data — same idea: one host folder, two containers.

3. Open the listing, then the file.

Browse and open
# listing
http://127.0.0.1:8080/
# direct file
http://127.0.0.1:8080/lake.jpg

curl -fsSI http://127.0.0.1:8080/lake.jpg

You should see a plain list of names (and folders). Click lake.jpg — or open the direct URL — to get the file.

curl -I
$ curl -fsSI http://127.0.0.1:8080/lake.jpg
HTTP/1.1 200 OK
Content-Type: image/jpeg

A 200 with Content-Type: image/jpeg means the mount worked. A 404 usually means the file is not in the mounted folder, or the name does not match.

Done when: you see the photograph at /lake.jpg on the To-Go Box port, while Jellyfin (if running) still uses its own port on the same folder. No upload button — the volume is the share.

Smoke check without a container: krazytogo -root ./data -addr :8080 with lake.jpg in ./data.

Serve files from a USB drive to go

Plug in a USB drive, mount its path into the Krazy To-Go Box, publish a port — take those files to go. If you already know mount on Linux, this is the same idea: attach the drive on the host, then hand that path to the box.

The official image stays tiny: a static file-server binary and the folder you mount. You do not install packages inside it. Need a helper tool? Run another container beside the box that shares the same mount.

1. Plug in the USB drive and mount it on the host (example path — use yours).

Mount the USB on Linux
# example — replace device and label to match your drive
sudo mkdir -p /mnt/usb
sudo mount /dev/sdX1 /mnt/usb
ls /mnt/usb

Desktop environments often auto-mount under /media/$USER/…. That path works too — copy it carefully into the next command.

2. Run the To-Go Box with that host path mounted at /data, and publish a port.

Docker — serve the USB folder
docker pull ghcr.io/crimsonflower420/krazytogo:latest
docker run -d --name krazy-usb \
  -p 8080:8080 \
  -v /mnt/usb:/data:ro \
  -e KRAZY_ROOT=/data \
  -e KRAZY_BROWSE=true \
  ghcr.io/crimsonflower420/krazytogo:latest

:ro keeps the share read-only inside the box (a good default for a borrowed drive). Drop :ro only if you intentionally want the container to write.

3. Open the listing on localhost (or your LAN IP if you published the port that way).

Open the share
http://127.0.0.1:8080/
# from another machine on the LAN (use your host IP):
# http://192.168.x.x:8080/

Localhost keeps the door on this machine. Publishing 8080 on a LAN address lets a peer browse the same USB files — you choose how open that door is.

Done when: names from the USB appear at http://127.0.0.1:8080/. Unmount the drive only after you stop the container.

Need file, curl, or similar against the share? Run a helper container that mounts the same /mnt/usb (or /data) beside the box — do not grow the official image.

Super krazy giant to-go box

Mount directories from all over your computer into one share. Photos here, docs there, a media disk somewhere else — the giant To-Go Box presents them together on a single port.

You already know mounts. Here you mount several host paths into one box (or gather them under one parent folder first). Put files on those folders however you like — including copying from another machine onto the host path. Do not install sshd inside the official image.

Path A — several binds into one box (teach this first)

Each -v attaches one host folder under a path inside the box. The server’s root can be a parent that contains those mounts.

Giant box — many mounts
docker pull ghcr.io/crimsonflower420/krazytogo:latest
docker run -d --name krazy-giant \
  -p 8080:8080 \
  -v "$HOME/Photos:/data/photos:ro" \
  -v "$HOME/Documents:/data/docs:ro" \
  -v /mnt/media:/data/media:ro \
  -e KRAZY_ROOT=/data \
  -e KRAZY_BROWSE=true \
  ghcr.io/crimsonflower420/krazytogo:latest

Browse http://127.0.0.1:8080/ — you should see photos/, docs/, and media/ as folders in the listing.

Path B — gather folders on the host, then one mount

If many binds feel noisy, make a parent directory of bind mounts (or symlinks) on the host, then mount just that parent at /data.

Host-side gather (example)
mkdir -p ~/togo-share
# bind or link the dirs you want visible
sudo mount --bind ~/Photos ~/togo-share/photos
sudo mount --bind ~/Documents ~/togo-share/docs

docker run -d --name krazy-giant \
  -p 8080:8080 \
  -v "$HOME/togo-share:/data:ro" \
  -e KRAZY_ROOT=/data \
  -e KRAZY_BROWSE=true \
  ghcr.io/crimsonflower420/krazytogo:latest

Getting a file onto the share

Copy into one of the host folders (the ones you mounted). From another machine, scp onto the host path works fine — the box only needs the file to land on disk.

scp onto a mounted host folder
# run on the laptop that has the file
scp ./lake.jpg user@server.example:Photos/lake.jpg
# then open http://server:8080/photos/lake.jpg (paths match your mounts)

Do not do this to the official image

  • Do not docker exec the To-Go Box looking for a shell or sshd.
  • Do not install openssh-server into the upstream image.
  • Do not publish port 22 on the file-server container. Port 8080 is the product.

Done when: several host directories show up as one browseable tree on a single port, and a file you copied onto one of those folders appears in the listing.

Go krazy — leave the toolkit on the other side of the wall.