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. Runs as a regular user. No shell and no package manager to install into. 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.

You will need: a media folder (or a sample data/ with a JPG), a container program (Docker, Podman, or Kubernetes), and a free host port (often 8080). Jellyfin is optional — the companion box works alone.

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.

Success looks like: a plain list of names at http://127.0.0.1:8080/, then the photograph at /lake.jpg on the To-Go Box port (matching the listing/success visuals above). Jellyfin, if running, still uses its own port on the same folder. No upload button — the volume is the share.

Common snag: connection refused or the wrong page usually means the host port mapping is off — try -p 18080:8080 and open http://127.0.0.1:18080/ if 8080 is already busy.

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 tools inside it. Need a helper? Run another container beside the box that shares the same mount.

You will need: a USB drive (or any host path), Linux mount access, a container program, and a published port. Optional: a LAN peer to open the listing from another machine.

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.

Success looks like: names from the USB appear at http://127.0.0.1:8080/ (or your LAN IP on that port). Click a file and it opens or downloads. Unmount the drive only after you stop the container.

Common snag: an empty listing or permission errors often mean the host path is wrong or the container user cannot read the mount — double-check the path you mounted at /data and that the files are world-readable (or owned for 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 try to log into the official image.

You will need: two or more folders on the host (photos, docs, media…), a container program, and one published port. Copying files onto those host folders is enough — the box only needs them on disk.

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 (or podman exec) the To-Go Box looking for a shell — there is none.
  • Do not install remote-login or package tools into the upstream image.
  • Do not publish a login port on the file-server container. Port 8080 (the file door) is the product.

Success looks like: several host directories show up as one browseable tree on a single port (folders like photos/, docs/ in the listing), and a file you copied onto one of those folders appears when you refresh.

Common snag: on Fedora/RHEL with Podman, a permission denied on the volume is often SELinux — add :Z (or ro,Z) to the -v flag. Harmless on hosts without SELinux.

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