rclone 1.76.0 on AWS User Guide
No longer open to new subscribers. The AWS Marketplace listing this guide was written for is closed to new subscriptions. If you already run it, your instances and this guide are unaffected. For what you can launch today, see rclone.
Overview
This guide covers launching and using the rclone 1.76.0 on Ubuntu 24.04 AMI from cloudimg on Amazon EC2. It is one version of the cloudimg backup and recovery listing on AWS Marketplace; you pick it as the software version when you subscribe and launch.
rclone is an open source command line program for managing files on cloud storage, often called "rsync for cloud storage". It copies, syncs, moves, checks and mounts files across more than seventy storage backends (Amazon S3 and S3 compatible stores, Azure Blob Storage, Google Cloud Storage and Drive, Backblaze B2, Dropbox, OneDrive, SFTP, WebDAV and many more), with checksum verified transfers, server side copies, client side encryption and bandwidth limits. Its remote-control API (rclone rcd) runs the same operations as jobs over HTTP, and the official rclone Web GUI drives that API from a browser.
Upstream rclone ships the API and the GUI for use on a desktop: on a server you have to add TLS, a password and a network boundary yourself. The cloudimg image does that for you:
- HTTPS and a password from the first boot. nginx serves the Web GUI and the remote-control API on port 443 (
https://<host>/) with a certificate generated on your instance's first boot for its DNS name and IP addresses; port 80 only redirects to it. First boot also generates a password unique to the instance for the useradminand writes it to/root/rclone-credentials.txt(root only). Only a bcrypt hash of it is stored for the services, and it is never passed on a command line or written to a log. - Checked twice. nginx asks for the password on every call to the API, and rclone itself checks the same password again on its own API, which listens on
127.0.0.1:5572only. Requests from other web sites and requests for host names the instance does not serve are refused. - Sandboxed, with the metadata service out of reach. rclone runs as an unprivileged
rcloneaccount in a sandboxed service that cannot write to/etc,/usror/boot. rclone connects to whatever storage you configure, so the instance metadata service and other link local addresses are blocked twice: the kernel firewall refuses every connection thercloneaccount opens to them (the Web GUI's API andsudo -u rclone rcloneon the command line alike), and systemd refuses them for the rclone, nginx and first boot services. That keeps the instance's own IAM credentials away from anything rclone is pointed at. Your VPC's private addresses (a NAS, MinIO, an SFTP server) and every public endpoint stay reachable. The AMI requires IMDSv2. - Built from source. rclone 1.76.0 is compiled from the upstream release source (pinned by SHA-256) with the pinned Go 1.27.4 toolchain, which fixes the Go standard library advisory in the upstream 1.76.0 binary. The Web GUI is rclone-web 1.2.1, the bundle in the rclone 1.76.0 source tree, pinned by SHA-256 and served from the image: nothing is downloaded at boot. Ubuntu 24.04 LTS is fully patched with unattended security upgrades switched on.
What is on the image: rclone 1.76.0 (/usr/local/bin/rclone; licence and build provenance in /usr/share/doc/rclone), the rclone Web GUI 1.2.1 (/usr/share/cloudimg-rclone-web, licence in /usr/share/doc/rclone-web), nginx, FUSE 3 for rclone mount from the command line (Step 8; the Web GUI's Mounts page cannot mount, because the rclone service runs without device access or privilege escalation), Ubuntu 24.04 LTS, cloud-init and the AWS Systems Manager agent.
Default user: ubuntu · Architecture: x86_64 · Recommended instance type: m5.large
Prerequisites
- An AWS account subscribed to the listing, an EC2 key pair and a VPC subnet.
- A security group that allows TCP 22 (SSH) and TCP 443 (Web GUI and API) from your own networks only. TCP 80 is optional: it only redirects browsers to HTTPS. Nothing else needs to be open.
- Credentials for the storage you want rclone to use (for Amazon S3, an access key of an IAM user or role session with access to your buckets; see Step 7).
Step 1: Launch the instance
In the AWS Marketplace listing choose Continue to Subscribe, then Continue to Configuration, pick rclone 1.76.0 on Ubuntu 24.04 as the software version and your Region, then Launch through EC2. Choose m5.large, your key pair and a security group as above. rclone keeps its configuration in /var/lib/rclone and a local transfer area in /srv/rclone on the root volume; increase the root volume in the launch wizard's storage section if you will stage large files on the instance.
With the AWS CLI (replace the values in angle brackets):
aws ec2 run-instances --region <region> --image-id <ami-id-from-the-listing> \
--instance-type m5.large --key-name <your-key-pair> \
--security-group-ids <your-security-group> --subnet-id <your-subnet> \
--metadata-options HttpTokens=required,HttpEndpoint=enabled \
--tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=rclone}]'
Step 2: Connect to your instance
| Version | SSH user |
|---|---|
| rclone 1.76.0 on Ubuntu 24.04 | ubuntu |
ssh -i <your-key.pem> ubuntu@<public-ip>
Step 3: Check the services
First boot generates the certificate and the password; the metadata firewall, rclone's remote-control API and nginx then start. Check them and the ports they listen on:
test -f /var/lib/cloudimg/rclone-firstboot.done && echo "first boot: done"
systemctl is-active cloudimg-rclone-egress rclone-rcd nginx
sudo ss -Htlnp | awk '{print $4, $6}' | sed -E 's/users:\(\("([^"]+)".*/\1/' | sort -u
first boot: done
active
active
active
0.0.0.0:22 sshd
0.0.0.0:443 nginx
0.0.0.0:80 nginx
127.0.0.1:5572 rclone
127.0.0.53%lo:53 systemd-resolve
127.0.0.54:53 systemd-resolve
[::]:22 sshd
[::]:443 nginx
[::]:80 nginx
nginx is the only service on the network (ports 80 and 443); rclone's API listens on 127.0.0.1:5572 only. The rclone build:
rclone version
rclone v1.76.0
- os/version: ubuntu 24.04 (64 bit)
- os/kernel: 7.0.0-1017-aws (x86_64)
- os/type: linux
- os/arch: amd64
- go/version: go1.27.4
- go/linking: static
- go/tags: none
Step 4: Get your URL and password
The credentials file is readable by root only. This prints it with the password hidden; sudo cat /root/rclone-credentials.txt shows it:
sudo sed -E 's/^(RCLONE_PASSWORD=).*/\1<hidden>/' /root/rclone-credentials.txt
# rclone 1.76.0 - generated on first boot by rclone-firstboot.service
# The password below is unique to this instance; none was baked into the image. Keep this file secret.
RCLONE_URL=https://ec2-52-23-159-188.compute-1.amazonaws.com/login?url=https://ec2-52-23-159-188.compute-1.amazonaws.com
RCLONE_HOST=ec2-52-23-159-188.compute-1.amazonaws.com
RCLONE_RC_URL=https://ec2-52-23-159-188.compute-1.amazonaws.com
RCLONE_USERNAME=admin
RCLONE_PASSWORD=<hidden>
RCLONE_CA_CERT=/etc/rclone/tls/rclone.crt
RCLONE_CERT_SHA256=75:CA:43:01:B6:F4:F6:98:21:7A:A0:57:1C:17:C9:F8:57:92:71:72:85:C1:F0:D6:1A:5A:3D:19:2D:BF:D7:0C
#
# Web GUI: open RCLONE_URL (the sign-in page, with this server as the rclone address RCLONE_RC_URL) and sign in with
# RCLONE_USERNAME and RCLONE_PASSWORD (the certificate is self-signed; see the guide). The same user and password
# authenticate every POST to the rc API.
# Command line (as the service account): sudo -u rclone rclone --config /var/lib/rclone/rclone.conf <command>
# New password: sudo rclone-rotate-password
# Change the name it serves as: sudo rclone-set-hostname <your-dns-name>
# User guide: https://www.cloudimg.co.uk/guides/rclone-1-76-0-on-ubuntu-24-04-aws/
Your instance shows its own DNS name and certificate fingerprint. What each value is for:
| Value | Used for |
|---|---|
RCLONE_URL |
The Web GUI sign-in page in your browser (it already carries this server as the rclone address) |
RCLONE_RC_URL |
The remote-control API address the Web GUI talks to (the same server) |
RCLONE_USERNAME / RCLONE_PASSWORD |
Signing in to the Web GUI, and Basic Auth on every API call |
RCLONE_CERT_SHA256 |
The fingerprint to compare with what your browser shows before you accept the self-signed certificate |
Step 5: Open the Web GUI
Open RCLONE_URL from Step 4 in your browser. The browser warns about the certificate the first time because it is self signed for this instance; compare the fingerprint it shows with RCLONE_CERT_SHA256 before you accept it, or install your own certificate (Step 10). The sign-in page already has this server as the rclone address; sign in with RCLONE_USERNAME and RCLONE_PASSWORD:

The Dashboard shows the rclone version, the transfer statistics and the remotes. The Web GUI may only load from and talk to this server (its Content Security Policy), so it can never send your password elsewhere; the upstream release notes and sponsor panels, which it would fetch from GitHub, stay empty:

To keep port 443 closed to the internet, reach the Web GUI through SSH instead. Forward local port 443 (which needs sudo on your workstation) and browse to https://localhost/; the sign-in page then uses https://localhost as the rclone address:
sudo ssh -i <your-key.pem> -N -L 443:localhost:443 ubuntu@<public-ip>
Step 6: Use the remote-control API
Everything the Web GUI does goes through rclone's remote-control API: every call is an HTTPS POST to https://<host>/<method> with a JSON body and the Web GUI user and password as Basic Auth. This calls it from the instance, passing the password to curl on its standard input so it never appears on a command line:
H=$(sudo sed -n 's/^RCLONE_HOST=//p' /root/rclone-credentials.txt)
api() { sudo sed -n 's/^RCLONE_PASSWORD=\(.*\)/user = "admin:\1"/p' /root/rclone-credentials.txt \
| curl -s --cacert /etc/rclone/tls/rclone.crt -K - -X POST -H 'Content-Type: application/json' --data "${2:-"{}"}" "https://$H/$1"; }
api core/version | jq -c '{version, goVersion, os, arch}'
api config/listremotes | jq -c .
{"version":"v1.76.0","goVersion":"go1.27.4","os":"linux","arch":"amd64"}
{"remotes":[]}
Long transfers can run as background jobs ("_async": true in the body returns a jobid; job/status reports on it). The rc documentation lists every method.
Step 7: Add a storage remote
A remote is a named storage location in /var/lib/rclone/rclone.conf (readable by the rclone account only). In the Web GUI open Remotes, choose Add New Remote, pick the storage type and fill in its settings:

The same is possible through the API. This creates demo-local, an alias for the instance's local transfer area /srv/rclone/demo, which the next steps use:
H=$(sudo sed -n 's/^RCLONE_HOST=//p' /root/rclone-credentials.txt)
api() { sudo sed -n 's/^RCLONE_PASSWORD=\(.*\)/user = "admin:\1"/p' /root/rclone-credentials.txt \
| curl -s --cacert /etc/rclone/tls/rclone.crt -K - -X POST -H 'Content-Type: application/json' --data "${2:-"{}"}" "https://$H/$1"; }
sudo -u rclone mkdir -p /srv/rclone/demo
api config/create '{"name":"demo-local","type":"alias","parameters":{"remote":"/srv/rclone/demo"}}' >/dev/null
api config/listremotes | jq -c .
{"remotes":["demo-local"]}
Or from the command line as the service account, with the interactive wizard (sudo -u rclone rclone --config /var/lib/rclone/rclone.conf config) or in one line. For Amazon S3 use the access key of an IAM user (or a role session) that can reach your bucket:
sudo -u rclone rclone --config /var/lib/rclone/rclone.conf config create mys3 s3 \
provider=AWS env_auth=false region=<your-region> access_key_id=<your-access-key-id> secret_access_key=<your-secret-access-key>
The instance's own IAM role cannot be used by rclone (env_auth=true): the image deliberately blocks the rclone account and the rclone service from the instance metadata service, so that no remote, URL or job rclone is given can read the instance's credentials (Step 9). Give rclone credentials of its own, scoped to the buckets it needs.
Step 8: Browse and transfer files
Browse a remote on the Explorer tab (pick it in the left column under Remotes) to upload and download files, create folders and start copy, move and sync transfers; Transfers shows the running jobs:


From the command line, run rclone as the rclone service account with its configuration, so it uses the same remotes and the same firewall as the Web GUI:
echo "hello from rclone" | sudo -u rclone tee /srv/rclone/demo/hello.txt >/dev/null
sudo -u rclone rclone --config /var/lib/rclone/rclone.conf lsl demo-local:
sudo -u rclone rclone --config /var/lib/rclone/rclone.conf copy demo-local: /srv/rclone/demo-copy --checksum
sudo -u rclone rclone --config /var/lib/rclone/rclone.conf check demo-local: /srv/rclone/demo-copy 2>&1 | tail -1
18 2026-11-14 12:07:25.732829061 hello.txt
2026/11/14 12:07:25 NOTICE: Local file system at /srv/rclone/demo-copy: 1 matching files
With your own remotes the same commands copy, sync and mount cloud storage, for example:
# Copy a local directory up to a bucket (checksum verified, resumable):
sudo -u rclone rclone --config /var/lib/rclone/rclone.conf copy /srv/rclone/exports mys3:<your-bucket>/exports --progress
# Make the destination match the source (deletes extra files on the destination: try --dry-run first):
sudo -u rclone rclone --config /var/lib/rclone/rclone.conf sync /srv/rclone/exports mys3:<your-bucket>/exports --dry-run
# Mount a bucket as a local directory (the mount point must belong to the rclone account):
sudo install -d -o rclone -g rclone /srv/rclone/mnt
sudo -u rclone rclone --config /var/lib/rclone/rclone.conf mount mys3:<your-bucket> /srv/rclone/mnt --daemon
sudo -u rclone fusermount3 -u /srv/rclone/mnt
Step 9: Check the security posture
These checks show the defaults are in place: the API refuses calls without the password or with a wrong one, requests from other web sites are refused, rclone's own loopback API checks the password too, and the rclone account cannot reach the instance metadata service:
H=$(sudo sed -n 's/^RCLONE_HOST=//p' /root/rclone-credentials.txt)
C="--cacert /etc/rclone/tls/rclone.crt -s -o /dev/null -X POST"
curl $C -w 'no password: %{http_code}\n' "https://$H/core/version"
curl $C -w 'wrong password: %{http_code}\n' -K <(printf 'user = "admin:%s"\n' "$(openssl rand -hex 12)") "https://$H/core/version"
curl $C -w 'from another site: %{http_code}\n' -H 'Origin: https://attacker.invalid' "https://$H/core/version"
curl -s -o /dev/null -w 'rclone API, no password: %{http_code}\n' -X POST http://127.0.0.1:5572/core/version
sudo -u rclone curl -s -m 5 -o /dev/null -w 'metadata from the rclone account: %{http_code}\n' http://169.254.169.254/latest/meta-data/ || true
sudo iptables -S CLOUDIMG-RCLONE-EGRESS
systemctl show -p IPAddressDeny --value rclone-rcd
no password: 401
wrong password: 401
from another site: 403
rclone API, no password: 401
metadata from the rclone account: 000
-N CLOUDIMG-RCLONE-EGRESS
-A CLOUDIMG-RCLONE-EGRESS -d 169.254.0.0/16 -p tcp -j REJECT --reject-with tcp-reset
-A CLOUDIMG-RCLONE-EGRESS -d 169.254.0.0/16 -j REJECT --reject-with icmp-port-unreachable
-A CLOUDIMG-RCLONE-EGRESS -d 168.63.129.16/32 -p tcp -j REJECT --reject-with tcp-reset
-A CLOUDIMG-RCLONE-EGRESS -d 168.63.129.16/32 -j REJECT --reject-with icmp-port-unreachable
168.63.129.16/32 fe80::/10 fd00:ec2::/32 169.254.0.0/16
000 means the connection was refused before it left the instance. Private addresses in your VPC and public endpoints are not affected.
Step 10: Rotate the password, use your own DNS name
To replace the Web GUI password (both nginx and rclone switch to the new one at once; running transfers continue):
sudo rclone-rotate-password
rclone-rotate-password: new password in /root/rclone-credentials.txt
To serve the Web GUI under your own DNS name, point the name at the instance and run the command below. It generates a new certificate for that name (and the instance's IP addresses) and makes nginx answer only for it (nginx keeps it across reboots):
sudo rclone-set-hostname <your-domain>
After a stop and start. Without an Elastic IP, stopping and starting the instance gives it a new public IP address and DNS name, and nginx drops requests for names it does not serve (the browser shows a closed connection). Either attach an Elastic IP before you rely on the address, or after each start serve the new public name (this reads it from the instance metadata, then issues a new certificate for it; open the new RCLONE_URL afterwards):
T=$(curl -s -X PUT -H 'X-aws-ec2-metadata-token-ttl-seconds: 60' http://169.254.169.254/latest/api/token)
NEW=$(curl -s -H "X-aws-ec2-metadata-token: $T" http://169.254.169.254/latest/meta-data/public-hostname)
sudo rclone-set-hostname "$NEW" --no-persist
sudo sed -n 's/^RCLONE_URL=//p' /root/rclone-credentials.txt
To use a certificate from your own CA or Let's Encrypt instead, put the certificate and key in place of /etc/rclone/tls/rclone.crt and /etc/rclone/tls/rclone.key (key mode 0600, owner root) and run sudo systemctl reload nginx.
Step 11: Server components
| Component | Where | Notes |
|---|---|---|
| rclone 1.76.0 | /usr/local/bin/rclone |
Built from source with Go 1.27.4; rclone version shows the build |
| rclone remote-control API | rclone-rcd.service, 127.0.0.1:5572 |
Runs as rclone; checks the password itself (/etc/rclone/rc.htpasswd) |
| rclone Web GUI 1.2.1 | /usr/share/cloudimg-rclone-web |
Static files served by nginx on GET |
| nginx | nginx.service, ports 80 and 443 |
TLS, Basic Auth on every POST, Host and origin checks |
| rclone configuration | /var/lib/rclone/rclone.conf |
Your remotes and their credentials, readable by rclone only |
| Local transfer area | /srv/rclone |
Writable by rclone |
| TLS certificate | /etc/rclone/tls/ |
Generated at first boot; replaced by rclone-set-hostname |
| Metadata firewall | cloudimg-rclone-egress.service |
Blocks the rclone account from 169.254.0.0/16, 168.63.129.16, fd00:ec2::/32 and fe80::/10 (the services are also blocked by systemd IPAddressDeny) |
| First boot | rclone-firstboot.service |
Runs once; writes /root/rclone-credentials.txt |
Step 12: Security recommendations
- Allow ports 22 and 443 in the security group from your own networks only, or close 443 and use the SSH tunnel in Step 5.
- Give rclone storage credentials with the least access it needs (one bucket, read only where you can), and rotate them in the Web GUI or with
rclone configwhen someone leaves. - Encrypt sensitive data before it leaves the instance with an rclone crypt remote.
- Rotate the Web GUI password (Step 10) if it may have been exposed, and use your own DNS name with a certificate from your own CA or Let's Encrypt.
- Keep the operating system patched; unattended security upgrades are on, and
sudo apt-get update && sudo apt-get upgradeapplies everything else.
Support and licensing
rclone and the rclone Web GUI are open source under the MIT licence; there is no per user or per CPU licence fee. The licences are in /usr/share/doc/rclone/ and /usr/share/doc/rclone-web/. cloudimg is not affiliated with or endorsed by the rclone project. The AMI price covers cloudimg's hardening, first boot setup and support.
- Email: support@cloudimg.co.uk
- Website: https://www.cloudimg.co.uk
- Support: 24 hours a day by email (support@cloudimg.co.uk), with a guaranteed response within 24 hours