Manyfold 3D Model Manager on AWS User Guide

Overview

Manyfold is an open source, 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 Docker Compose stack and runs it behind nginx as a systemd service, so your model library is online within minutes of launch.

The appliance is the official container stack: the Ruby on Rails web application on Puma, two Sidekiq background workers that render model thumbnails, PostgreSQL 15 for the catalogue and user accounts, and Redis 7.2 for the job queue. A host nginx reverse proxy on port 80 is the only service published on the public interface; the app, PostgreSQL and Redis bind to the loopback interface only. All stateful data, the database, the render thumbnails and your uploaded model files, lives on a dedicated, independently resizable EBS volume mounted at /var/lib/manyfold, captured into the image so every instance is re-provisioned with the disk.

Multi-user mode is enabled, so the appliance is a real multi-user product with accounts, roles and per-user libraries. Every application secret and a fresh administrator account are generated on the first boot of each deployed instance, so two instances launched from the same Amazon Machine Image never share a credential. The administrator username, email and password are written to /root/manyfold-credentials.txt with mode 0600 so that only the root user can read them.

Prerequisites

Before you deploy this image you need:

• An Amazon Web Services account where you can launch EC2 instances
• IAM permissions to launch instances, create security groups, and subscribe to AWS Marketplace products
• An EC2 key pair in the target Region for SSH access to the instance
• A VPC and subnet in the target Region, with a security group allowing inbound port 22 from your management network and inbound ports 80 and 443 from the networks your users will reach Manyfold from
• The AWS CLI (version 2) installed locally if you plan to deploy from the command line

m5.large (2 vCPU / 8 GB RAM) or larger is recommended: the Rails app plus the render workers need the memory for a comfortable library.

Step 1: Launch the Instance from the AWS Marketplace

Sign in to the AWS Management Console, open the EC2 service, and select Launch instance. Under Application and OS Images choose AWS Marketplace AMIs and search for Manyfold. Select the cloudimg listing and choose Select, then Continue on the subscription summary.

Pick an instance type of m5.large or larger. Choose your EC2 key pair under Key pair (login). Under Network settings select your VPC and subnet, and either create or select a security group that allows inbound port 22 from your management network and inbound ports 80 and 443 from the networks your users will use. Leave the root and data volumes at their default sizes or larger.

Select Launch instance. First boot initialisation takes a couple of minutes after the instance state becomes Running and the status checks pass, while the stack rotates its secrets, recreates the database and creates your administrator account.

Step 2: Launch the Instance from the AWS CLI

The following block launches an instance from the cloudimg Manyfold Marketplace AMI into an existing subnet and security group. Replace <ami-id> with the AMI ID shown on the Marketplace listing, <key-name> with your EC2 key pair name, <subnet-id> with your subnet ID, and <security-group-id> with a security group that opens ports 22, 80, and 443 as described above.

aws ec2 run-instances \
  --image-id <ami-id> \
  --instance-type m5.large \
  --key-name <key-name> \
  --subnet-id <subnet-id> \
  --security-group-ids <security-group-id> \
  --metadata-options "HttpTokens=required,HttpEndpoint=enabled" \
  --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=manyfold}]'

Connecting to your instance

SSH in as the login user for your instance's operating system. Manyfold is served on port 80.

Replace <public-ip> with the public IP of your instance:

ssh ubuntu@<public-ip>

Step 3: 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, so nginx is the only service exposed on the public interface.

Step 4: 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, manyfold3d/manyfold:0.146.0, postgres:15 and redis:7.2-alpine, and the three containers, manyfold-app-1, manyfold-postgres-1 and manyfold-redis-1, all in the Up state.

Step 5: Confirm the data volume is mounted

All stateful Manyfold data, the database, the rendered thumbnails and your uploaded model files, lives on a dedicated EBS volume 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 6: 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 7: Read the per-instance 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 8: Sign in to Manyfold

Open http://<public-ip>/ in your browser. You are redirected to the sign-in page. Enter the MANYFOLD_ADMIN_EMAIL and MANYFOLD_ADMIN_PASSWORD from Step 7 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:

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-instance administrator authenticates end to end.

Step 9: Explore Manyfold

After signing in you land on the dashboard, with a search box across your whole library and a recent-activity feed. The top bar gives you Models, Creators and Collections, plus Add content and Scan to bring your models in.

The Models page is your library grid. A fresh appliance starts empty, with a default library at /libraries ready for you to fill; once you add models the grid shows a rendered thumbnail for each one, generated by the background worker.

Step 10: Manage libraries and users

Open Site Settings (the gear icon) to manage your libraries, file settings, appearance, mesh analysis, plugins and, because multi-user mode is enabled, user accounts and moderation. The statistics tiles summarise your models, files, creators, collections, accounts and tags.

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 volume 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. To inspect the application logs, tail the app container:

cd /opt/manyfold && sudo docker compose logs --tail 20 app

To restart the stack, run sudo systemctl restart manyfold.service, then check it with sudo systemctl status manyfold.service --no-pager.

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 instance 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 volume 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.