Transmute

Sign in to the Azure Portal. Click Create a resource, search the Marketplace for Transmute by SecureAnyCloud, and click Create.

On Basics, pick your subscription, resource group, region and size. Under Administrator account, choose SSH public key and paste your key. Under Inbound port rules, allow SSH (22) and HTTP (80). Then click Review + create, followed by Create.

RG="transmute-prod"; LOCATION="eastus"; VM_NAME="transmute-01" IMAGE_URN="sac1647283583153:transmute:default:latest" SSH_KEY="$(cat ~/.ssh/id_rsa.pub)" az group create --name "$RG" --location "$LOCATION" az network vnet create -g "$RG" --name transmute-vnet --address-prefix 10.100.0.0/16 --subnet-name transmute-subnet --subnet-prefix 10.100.1.0/24 az network nsg create -g "$RG" --name transmute-nsg az network nsg rule create -g "$RG" --nsg-name transmute-nsg --name allow-ssh --priority 100 \
  --source-address-prefixes "<your-mgmt-cidr>" --destination-port-ranges 22 --access Allow --protocol Tcp az network nsg rule create -g "$RG" --nsg-name transmute-nsg --name allow-http --priority 110 \
  --destination-port-ranges 80 --access Allow --protocol Tcp
# Accept the Marketplace terms once per subscription (required before the first CLI deploy)
az vm image terms accept --urn sac1647283583153:transmute:default:latest
az vm create -g "$RG" --name "$VM_NAME" --image "$IMAGE_URN" \
  --size Standard_B2s --storage-sku StandardSSD_LRS \
  --admin-username azureuser --ssh-key-values "$SSH_KEY" \
  --vnet-name transmute-vnet --subnet transmute-subnet --nsg transmute-nsg --public-ip-sku Standard

Replace <sub-id> and <version> with your subscription ID and the image version shown on the listing. Replace <your-mgmt-cidr> with the network you administer from.

On the first boot of each VM, Transmute generates its own per-instance secrets and claims its own administrator account before the web port is opened. Nothing is baked into the image.

Wait a minute after first boot, then SSH in and read the credentials file (it is 0600 root:root):

sudo cat /root/transmute-credentials.txt

The file contains everything unique to this instance:

• TRANSMUTE_USERNAME and TRANSMUTE_PASSWORD: the administrator login you use in the web UI. The administrator has full access, including user management.
• TRANSMUTE_URL: the web address of this instance, resolved from its public IP on first boot.

A per-VM token signing key is written alongside them in /opt/transmute/.env, also 0600 root:root. It is generated on this VM and never exists in the image. Persisting it matters. Upstream generates a fresh random key in memory whenever the variable is empty, which would sign everyone out each time the container restarted.

Confirm the services and container are healthy:

sudo systemctl is-active docker transmute-firstboot transmute transmute-postboot nginx

active active active active active

sudo docker compose -f /opt/transmute/docker-compose.yml ps --format 'table {{.Service}}\t{{.Status}}\t{{.Ports}}'

SERVICE STATUS PORTS transmute Up 52 seconds (healthy) 127.0.0.1:3313->3313/tcp

The application container publishes to loopback only. Host nginx on port 80 is the single public entry point.

A file converter reachable on a public IP is an attractive target. It accepts arbitrary uploads, spends CPU and disk on them, and media parsers are a classic memory-safety attack surface. This image is locked down by default in four ways.

The administrator seat is already taken. Upstream Transmute makes the first account an administrator and accepts that request with no authentication while the account list is empty. transmute-postboot.service claims it first, over the loopback port, with a password generated for this VM. Afterwards the same endpoint refuses all requests. The application's own code enforces this, not a configuration flag.

The public port is closed during bootstrap. Host nginx, the only public listener, does not start until the administrator exists. It waits for a bootstrap-ready marker that post-boot creates only after the account has been claimed. Port 80 stays closed for the whole bootstrap window, so a stranger can never claim the instance.

Nothing is anonymous. Guest and unauthenticated conversions ship disabled, so every upload and conversion requires a login. There is no open self-registration. Once the administrator exists, creating further accounts requires an administrator token.

The app is not directly exposed. The application listens on 127.0.0.1:3313 only. nginx caps a single upload at 1 GB and streams request bodies rather than spooling them into memory.

ss -tln | grep -E ':(80|3313) ' | awk '{print $1, $4}'

LISTEN 0.0.0.0:80 LISTEN 127.0.0.1:3313 LISTEN [::]:80

The image checks each of these claims at runtime. You can reproduce the checks yourself:

curl -s -o /dev/null -w 'GET /api/files -> %{http_code}\n' http://127.0.0.1/api/files
curl -s -o /dev/null -w 'POST /api/guest/session -> %{http_code}\n' -X POST http://127.0.0.1/api/guest/session
curl -s http://127.0.0.1/api/users/bootstrap-status; echo

GET /api/files -> 401 POST /api/guest/session -> 403 {"requires_setup":false,"user_count":1}

The instance refuses an anonymous file listing and refuses guest sessions. It reports that setup is complete with exactly one account, the administrator claimed for this VM.

Open http://<public-ip>/ in a browser. You are sent to the sign-in page, because nothing on this instance is public.

Sign in with the TRANSMUTE_USERNAME and TRANSMUTE_PASSWORD from the credentials file. You land on the Workspace, which is the converter. Drop a file onto the drop zone or click to browse. Then pick the target format on the file's row and choose a quality preset.

Click Convert. When the job finishes, the file moves to Completed and the download, preview and delete actions appear on its row.

The Jobs page keeps the history of everything this instance has converted, with the resulting format, size and status for each job. Image and audio conversions both appear here. The ffmpeg pipeline inside the image handles audio.

The preview action renders the file in the browser without downloading it, so you can check a result before saving it.

You can also pull in a file by URL instead of uploading it. Use the URL for Transmute to grab field on the workspace. The instance itself makes that fetch, so point it only at sources you trust.

The image ships a verification script that drives the whole product through the public front door. It checks the output's magic bytes, not just that a request returned HTTP 200. It uploads a generated PNG and converts it to JPEG. It then uploads a generated WAV and converts it to FLAC through ffmpeg. Finally it asserts that the downloaded bytes really are a JPEG and a FLAC.

sudo /usr/local/sbin/transmute-roundtrip.sh

OK round-trip: url=http://<public-ip>/ user=admin; ready=200; anon /api/files 401; admin seat taken (POST /api/users 401); guest 403; wrong password 401; login 200 + JWT; PNG->JPEG output magic ffd8ff (1039 bytes); WAV->FLAC output magic fLaC via ffmpeg

ffd8ff is the JPEG start-of-image marker and fLaC is the FLAC stream marker, so both conversions produced files in the requested format.

Transmute delegates to a set of well-known open source tools, all of which ship inside the image. The image records the exact inventory it was built with. The build refuses to proceed if the bundled ffmpeg is not redistributable.

sudo docker exec transmute ffmpeg -hide_banner -version | head -1

ffmpeg version 7.1.5-0+deb13u1 Copyright (c) 2000-2026 the FFmpeg developers

sudo sed -n '7,15p' /usr/share/doc/transmute/MEDIA-STACK.txt

Media + document tooling inside the image (all redistributable): ffmpeg 7:7.1.5-0+deb13u1 ghostscript 10.05.1~dfsg-1+deb13u1 inkscape 1.4-6 libreoffice-impress 4:25.2.3-2+deb13u5 tesseract-ocr 5.5.0-1+b1 unrar-free 1:0.3.1-1 ffmpeg banner: ffmpeg version 7.1.5-0+deb13u1 Copyright (c) 2000-2026 the FFmpeg developers ffmpeg build : verified NOT --enable-nonfree, and free of libfdk-aac.

The full inventory, with the license of each component, is at /usr/share/doc/transmute/MEDIA-STACK.txt. The upstream MIT license is at /usr/share/doc/transmute/LICENSE. ImageMagick is not included. Upstream removes it and its libraries from the image, and the image conversion path uses Pillow and PyMuPDF instead.

The instance cleans up uploaded and converted files automatically, so a busy instance does not fill its disk. Set the retention window per account on the Settings page. It defaults to 60 minutes. Raise it to keep results longer, or lower it if you handle sensitive material. Deleting a file from the Files or Jobs page removes it immediately.

The administrator creates additional users from the account menu. There is no open self-registration, so nobody can create an account on your instance without you.

Manage the service with ordinary systemd commands:

sudo systemctl restart transmute
sudo systemctl status transmute --no-pager | head -5

Read the application logs from the container:

sudo docker logs --tail 20 transmute

If you reach the VM by a DNS name instead of its IP address, set APP_URL in /opt/transmute/.env to that URL. Restart the service so that links the application generates match how people reach it.