Sharry

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 Sharry. Select the SecureAnyCloud listing and choose Select, then choose Continue on the subscription summary.

Pick an instance type of m5.large or larger. Sharry runs on the JVM and benefits from memory. 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 use. Leave the root volume at the default size or larger.

Select Launch instance. First-boot initialization takes approximately one to two minutes after the instance state becomes Running. During this time, Sharry generates its per-instance secrets, starts the server, and proves an authenticated login round trip before it finishes.

The following command launches an instance from the SecureAnyCloud Sharry 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 earlier.

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> \
  --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=sharry}]'

Connect over SSH with the key pair you selected and the public IP address of the instance. The SSH login user depends on the operating system of the AMI variant you launched:

AMI variant SSH login user

Sharry 1.16 on Ubuntu 24.04 ubuntu

The first-boot service completes before the SSH daemon becomes ready, so the credentials file is always in place when you log in for the first time.

ssh <login-user>@<public-ip>
sudo cat /root/sharry-credentials.txt

The plain text file contains the Sharry URL, the administrator user (admin), the per-instance administrator password and the signup invite password. From the same SSH session, you can confirm that the deployment is healthy. The health endpoint is open and needs no authentication:

curl -fsS http://127.0.0.1/healthz

ok

You can also read the running Sharry version from the open info endpoint:

curl -fsS http://127.0.0.1/api/v2/open/info/version

{"version":"1.16.0","builtAtMillis":1780603368255,"builtAtString":"2026-06-04 20:02:48.255+0000","gitCommit":"bcea4784dd4e760a3a6c6791cf6855c0cb614b06","gitVersion":"1.16.0"}

An ok health response confirms that the full stack (nginx, the Sharry server and PostgreSQL) is serving.

Open a web browser and navigate to http://<public-ip>/. The Sharry sign-in page appears. Enter the user admin and the password from /root/sharry-credentials.txt.

The Sharry sign-in page is served on first boot with a per-instance administrator account.

You can verify the same login from the command line. The following command posts the administrator credentials to the open login endpoint and returns a session token on success:

curl -s -H 'Content-Type: application/json' -X POST http://127.0.0.1/api/v2/open/auth/login -d '{"account":"admin","password":"<SHARRY_ADMIN_PASSWORD>"}'

After you sign in, you reach the Sharry home page, where you can create a share, create an upload alias, or view your existing shares and aliases.

The Sharry home page lets you create a share, create an alias, or view existing shares and aliases.

From the home page, choose Create Share. Drag files onto the drop zone or use Select Files, add an optional description (Markdown is supported), set a validity period and a maximum number of views, and optionally set a password. Then choose Submit to upload.

The send-files page shows the upload size, which reflects the server's configured maximum. Uploads are chunked and resumable.

Your shares are listed under View Shares, showing each share's name, maximum views, published state, file count, size and creation time.

The Your Shares list shows a published share with one uploaded file.

Open a share and choose Share Link (or Publish). Sharry generates a distinct public URL that anyone can open without a Sharry account, subject to the validity period, maximum views and optional password you set. Copy the link and send it to your recipient. To revoke access immediately, choose Unpublish at any time.

A published share shows its description, the uploaded file, and the Share Link and Add files actions.

Recipients open the public link, see the description and file list, and download individual files or the whole share as a zip. The server binds only to loopback and nginx fronts it on port 80, so the public link uses the instance address that first boot recorded in the credentials file.

To collect files from someone who has no Sharry account, choose Create Alias from the home page. An alias is a stable URL that you can hand out. Anyone with the link (and the alias password, if you set one) can upload files to you, and each upload becomes a share that you own. This is the reverse of publishing, and it suits intake from suppliers, applicants or clients.

Sharry uses invitation-based signup. As the administrator, generate a signup invitation key. The required invite password is the SHARRY_SIGNUP_INVITE_PASSWORD value in /root/sharry-credentials.txt. Share the key and the signup URL with the new user. The new user completes signup to create an account, with their own shares and aliases.

Sharry's configuration controls the upload limit. Edit /etc/sharry/sharry.conf with your preferred editor (for example sudo nano /etc/sharry/sharry.conf) and set a max-size under backend.upload. Add or adjust the following inside sharry.restserver { backend { upload { ... } } }:

backend { upload { max-size = "5G" } }

Then restart Sharry:

sudo systemctl restart sharry.service

nginx is already configured with client_max_body_size 0, so the proxy does not cap uploads. Sharry enforces its own limit.

Point a DNS A record at the instance's public IP, then install Certbot and obtain a certificate. nginx already fronts Sharry on port 80, and Certbot configures TLS on 443 and the HTTP-to-HTTPS redirect:

sudo apt-get update
sudo apt-get install -y certbot python3-certbot-nginx
sudo certbot --nginx -d sharry.example.com

After TLS is in place, update Sharry's base-url in /etc/default/sharry (the -Dsharry.restserver.base-url= option) to your https://sharry.example.com address and restart sharry.service, so that public share links and the auth cookie use the correct HTTPS URL.

All Sharry state lives on the dedicated data volume mounted at /var/lib/sharry: the PostgreSQL cluster under /var/lib/sharry/pgdata and the uploaded file blobs under /var/lib/sharry/files. Back up the database with pg_dump and snapshot the file store, or take an EBS snapshot of the data volume:

sudo -u postgres pg_dump sharry | gzip > /var/tmp/sharry-db-$(date +%F).sql.gz

Apply operating system updates with sudo apt-get update && sudo apt-get upgrade and reboot during a maintenance window. Manage the services with systemctl (sharry.service, nginx.service and postgresql).