I've used plenty of cloud storage services over the years.

They're convenient, but eventually I started wondering why I was paying for storage when I already had a server sitting around with plenty of disk space.

That's when I started looking at Seafile.

If you've never used it before, Seafile is a self-hosted file-sync and collaboration platform. Think of something somewhere between Google Drive and Dropbox, except you run the server yourself.

And honestly, getting it running was easier than I expected.

What we're building

The end result is going to look something like this:

Your Computer / Phone
          ↓
   https://files.example.com
          ↓
       Internet
          ↓
       Seafile
          ↓
      Your Storage

You can then use Seafile to sync files between computers and access them through the web or supported clients.

For this tutorial, I'm going to use:

Ubuntu Server
Docker
Docker Compose
Seafile Community Edition
A domain/subdomain
Caddy for HTTPS
Your own storage

Seafile's current Docker deployment includes Seafile, its database, and other supporting services, with Caddy handling external access and SSL in the standard single-node setup.

Step 1 — Prepare the server

I'm assuming you already have a Linux server running.

First, update it:

sudo apt update
sudo apt upgrade -y

You'll also need Docker and Docker Compose installed.

Check that Docker is working:

docker --version

And:

docker compose version

If both commands return a version number, you're ready.

Step 2 — Create the Seafile directory

I like keeping self-hosted applications organized, so let's create a dedicated directory:

sudo mkdir -p /opt/seafile
cd /opt/seafile

This is where we'll keep the Seafile Docker configuration.

Seafile's Docker documentation uses /opt/seafile for the Docker configuration and separate persistent storage locations for the database and application data.

Step 3 — Download the Seafile configuration

Seafile provides the Docker configuration files directly.

For the Community Edition setup:

wget -O .env https://manual.seafile.com/14.0/repo/docker/ce/env

wget https://manual.seafile.com/14.0/repo/docker/ce/seafile-server.yml

wget https://manual.seafile.com/14.0/repo/docker/seadoc.yml

wget https://manual.seafile.com/14.0/repo/docker/caddy.yml

Now you should have something similar to:

/opt/seafile/
├── .env
├── seafile-server.yml
├── seadoc.yml
└── caddy.yml

The exact files and configuration can change between Seafile releases, so it's worth checking the current Seafile documentation before doing a fresh installation.

Step 4 — Configure Seafile

Open the environment file:

nano .env

This is where you'll configure things like:

SEAFILE_SERVER_HOSTNAME=files.example.com
SEAFILE_SERVER_PROTOCOL=https

You'll also configure your administrator account and passwords according to the current template.

Don't use an example password from a tutorial.

Generate a strong password and keep it somewhere safe.

One nice thing about this setup is that you don't have to manually create every Docker container yourself. The Compose files take care of the supporting services.

Step 5 — Point your domain to the server

Before HTTPS can work properly, your domain needs to point to your server.

For example, I might create:

files.example.com

Then create a DNS record:

Type: A
Name: files
Value: YOUR.SERVER.IP

So when I visit:

https://files.example.com

the request reaches my server.

If you're using Cloudflare, you can manage the DNS record there.

Step 6 — Start Seafile

Once you've configured .env, start the containers:

docker compose -f seafile-server.yml -f seadoc.yml -f caddy.yml up -d

Give it a little time.

Then check your containers:

docker ps

You should see the Seafile services running.

If something isn't working, don't immediately start changing random settings.

Check the logs first:

docker compose logs -f

That's usually where you'll find the answer.

Step 7 — HTTPS

This is one of the parts I really like about the newer Seafile Docker setup.

Caddy handles HTTPS in the standard Docker deployment. It can automatically obtain and manage certificates when the domain is configured correctly.

That means you don't necessarily have to manually configure Nginx and Certbot just to get HTTPS working.

Once everything is configured correctly, you should be able to open:

https://files.example.com

instead of:

http://files.example.com

And yes, you absolutely want HTTPS if this server is going to be accessible from the internet.

Step 8 — Log into Seafile

Open your domain:

https://files.example.com

You should eventually get the Seafile login screen.

And that's it.

You now have your own cloud storage server.

Step 9 — Install the desktop client

This is where Seafile starts becoming really useful.

Install the Seafile client on your computer and connect it to your server.

You can then have a folder on your computer that automatically synchronizes with your Seafile server.

For example:

My Computer
    ↓
Seafile Client
    ↓
files.example.com
    ↓
Your Server

Now you don't have to constantly open a browser just to access your files.

Step 10 — Install the mobile app

The same idea works on your phone.

Instead of keeping everything inside a third-party cloud account, your phone can connect back to your own Seafile server.

This is particularly useful if you're trying to build your own private cloud instead of putting everything into one company's ecosystem.

Don't forget backups

This is probably the most important part of the entire tutorial.

Self-hosting is not the same thing as having a backup.

If your server has one hard drive and that drive dies, your files can disappear.

I'd recommend something like:

             Seafile
                │
        ┌───────┴───────┐
        ↓               ↓
   Local Backup    Off-Site Backup

And don't just assume your backup works.

Every once in a while, actually restore something.

That's how you find out whether your backup strategy is real or just wishful thinking.

A few things I'd add later

Once Seafile is running, there's a lot more you can do.

You could add:

Additional storage
Automated backups
Monitoring
Cloudflare DNS
A dedicated reverse proxy
S3-compatible object storage
Multiple users
Shared libraries
Online document editing
Server monitoring
Automated update notifications

You can also put other services on the same server and give each one its own subdomain.

For example:

files.example.com
photos.example.com
notes.example.com
status.example.com

That's where self-hosting gets addictive.

You start with one application.

Then suddenly you're running your own little private cloud.

Was Seafile worth setting up?

For me, the biggest advantage isn't just avoiding another monthly subscription.

It's having control.

I know where the server is.

I control the storage.

I control the domain.

I decide who has access.

And if I want to move the whole thing somewhere else later, I can.

That's really the appeal of self-hosting.

You aren't just using someone else's service.

You're building your own.

Useful links

If you're following along, I'd recommend checking Seafile's current documentation before deploying because configuration files and version-specific instructions can change.

Seafile Docker Community Edition:
https://manual.seafile.com/latest/setup/setup_ce_by_docker/

Seafile Caddy / HTTPS:
https://manual.seafile.com/12.0/setup/caddy/