Manyfold on Ubuntu 24.04 on Azure User Guide

Overview

Manyfold is a self-hosted digital asset manager for 3D-print files. It gives you a searchable web library for your STL, 3MF and OBJ models, with tagging, collections, geometry analysis, render thumbnails generated by background workers, and multi-user accounts with roles, so a household, makerspace or team can organise a growing 3D model collection on infrastructure they own instead of a third-party service. The cloudimg image installs Manyfold 0.146.0 as the official container stack and runs it behind nginx as a systemd service, so your model library is online within minutes of launch.

What is included:

• Manyfold 0.146.0 (AGPL-3.0) deployed from the official manyfold3d/manyfold Docker image, pinned so the image never silently upgrades at build time
• Docker Engine (Docker CE) + the Docker Compose plugin, installed from the official Docker package repository
• The Manyfold stack: the app container (the Rails web application on Puma port 3214 plus the two Sidekiq render/analysis workers, run together via foreman), postgres (PostgreSQL 15) and redis (pinned to the BSD-3-Clause redis:7.2-alpine line)
• Multi-user mode enabled, with the f3d renderer bundled so the library grid shows rendered model thumbnails out of the box
• A system nginx reverse proxy on port 80 forwarding to the app on 127.0.0.1:3214, with the WebSocket upgrade headers Hotwire needs, plus an unauthenticated static /health endpoint
• All stateful data - the PostgreSQL database, the rendered thumbnails and every uploaded model file - on a dedicated 40 GiB data disk mounted at /var/lib/manyfold (Docker's data-root is relocated there), independently resizable and re-provisioned on every VM
• A per-VM administrator account (username, email and a generated password) created at first boot, with a fresh Rails secret key base and a fresh database password rotated per instance, and a default library ready at /libraries
• Three systemd units: nginx.service, manyfold.service (a oneshot wrapper around docker compose up -d) and manyfold-firstboot.service
• 24/7 cloudimg support

Prerequisites

An active Azure subscription, an SSH key, and a VNet plus subnet. Standard_B2ms (2 vCPU / 8 GB RAM) is the recommended size - the Rails app plus the render workers need the memory for a comfortable library. NSG inbound rules: allow 22/tcp from your management CIDR for SSH and 80/tcp from the CIDR that needs the Manyfold web app (add 443/tcp if you enable HTTPS).

Step 1: Connect over SSH

Replace <vm-ip> with the public IP of your VM. The default login user is azureuser.

ssh azureuser@<vm-ip>

Step 2: Confirm the services are active

sudo systemctl is-active docker.service nginx.service manyfold.service
sudo ss -tlnp | grep -E ':80 |:3214 '

You should see active printed three times. The ss output shows nginx listening publicly on port 80, while the app is bound to the loopback interface only on 127.0.0.1:3214 - nginx is the only service exposed on the public interface.

Step 3: Confirm the Manyfold containers are running

grep image /opt/manyfold/docker-compose.yml
cd /opt/manyfold && sudo docker compose ps --format "table {{.Name}}\t{{.Image}}\t{{.Status}}"

You should see the pinned image tags and the three containers - manyfold-app-1, manyfold-postgres-1 and manyfold-redis-1 - all in the Up state.

Step 4: Confirm the data disk is mounted

All stateful Manyfold data - the database, the rendered thumbnails and your uploaded model files - lives on a dedicated data disk mounted at /var/lib/manyfold.

findmnt /var/lib/manyfold
df -h /var/lib/manyfold

findmnt shows the device backing /var/lib/manyfold and df confirms the 40 GiB volume.

Step 5: Check the health endpoint

The nginx reverse proxy serves an unauthenticated static /health endpoint on port 80, and the Manyfold app redirects the site root to the sign-in page when you are not logged in.

curl -s http://localhost/health
curl -s -o /dev/null -w "%{http_code}\n" http://localhost/

/health returns OK and / returns 302 (a redirect to the sign-in page), confirming nginx and the app are both up and that access is authenticated.

Step 6: Read the per-VM admin credentials

A unique administrator username, email and password are generated for your instance on its first boot and written to a root-only file.

sudo cat /root/manyfold-credentials.txt

This file lists MANYFOLD_URL (where to sign in), MANYFOLD_ADMIN_USERNAME, MANYFOLD_ADMIN_EMAIL and MANYFOLD_ADMIN_PASSWORD. Store the password somewhere safe.

Step 7: Sign in to Manyfold

Open http://<vm-ip>/ in your browser. You are redirected to the sign-in page. Enter the MANYFOLD_ADMIN_EMAIL and MANYFOLD_ADMIN_PASSWORD from Step 6 and sign in.

You can also verify the login from the command line against the Devise sign-in form - a correct password is accepted with a 303 redirect to the dashboard:

EMAIL=$(sudo grep '^MANYFOLD_ADMIN_EMAIL=' /root/manyfold-credentials.txt | cut -d= -f2-)
PASS=$(sudo grep '^MANYFOLD_ADMIN_PASSWORD=' /root/manyfold-credentials.txt | cut -d= -f2-)
JAR=$(mktemp)
TOKEN=$(curl -s -c "$JAR" http://localhost/users/sign_in | grep -oE 'name="authenticity_token"[^>]*value="[^"]+"' | head -1 | sed -E 's/.*value="([^"]+)".*/\1/')
curl -s -b "$JAR" -c "$JAR" -o /dev/null -w "%{http_code}\n" -X POST http://localhost/users/sign_in \
  --data-urlencode "authenticity_token=$TOKEN" \
  --data-urlencode "user[email]=$EMAIL" \
  --data-urlencode "user[password]=$PASS"

A 303 confirms the per-VM administrator authenticates end to end.

Step 8: Browse your model library

After signing in you land on your library. The Models grid shows every model in the library with a rendered thumbnail generated by the background worker. A default library at /libraries is ready for you to fill with your own models.

Open a model to see its files, metadata, tags and a larger interactive render:

Step 9: Manage libraries and users

Open Settings (the gear icon) to manage your libraries, appearance, mesh analysis, plugins and - because multi-user mode is enabled - user accounts and moderation. The Libraries page shows the storage service, path and model counts for each library.

To add your own 3D models, either upload them from the web UI with Add content, or copy files into a library folder on the data disk and run a Scan from the settings page - Manyfold imports the models and the render workers generate their thumbnails.

Managing the stack

The Manyfold stack is wrapped by the manyfold.service systemd unit, which runs docker compose up -d from /opt/manyfold.

sudo systemctl restart manyfold.service
sudo systemctl status manyfold.service --no-pager

To inspect the application logs, tail the app container:

cd /opt/manyfold
sudo docker compose logs --tail 50 app

Enabling HTTPS

The image serves plain HTTP on port 80. For any public deployment, put TLS in front with your own domain. Point a DNS A record at the VM public IP, then install a certificate with certbot's nginx plugin. Outline:

• Install certbot and the nginx plugin from the Ubuntu repositories.
• Run certbot against your domain to obtain and install a certificate into the nginx site.
• Once TLS is terminating at nginx, set PUBLIC_HOSTNAME=your-domain and HTTPS_ONLY=enabled in /opt/manyfold/.env, then restart the stack with sudo systemctl restart manyfold.service so Manyfold generates correct https:// URLs.

Use your own registered domain in place of any example placeholder.

Maintenance

The OS receives unattended security updates. To update Manyfold itself, edit the pinned image tag in /opt/manyfold/docker-compose.yml, then from /opt/manyfold run sudo docker compose pull followed by sudo systemctl restart manyfold.service (the app container runs the database migrations automatically on start). Always snapshot the /var/lib/manyfold data disk before a major version upgrade.

Support

Backed by 24/7 cloudimg support. Manyfold is a trademark of its respective owners. This image is provided by cloudimg and is not affiliated with or endorsed by the Manyfold project.