VPS Tutorials
Mount Cloud Storage on a VPS with rclone: Cache and Quotas (2026)
Mount Google Drive, OneDrive or a supported WebDAV bridge with rclone. Verify provider eligibility, VFS cache, FUSE, service permissions and traffic costs; remote capacity does not expand the local disk.

Even a 1 TB VPS disk can run short with only 100 GB left for large archives and transfers. rclone can expose cloud storage as a mounted directory, but it does not enlarge the local disk or provide unlimited free capacity. Subscription quotas, VPS traffic charges, API limits and local cache space still apply.
This guide covers Google Drive/OneDrive mounting and a generic WebDAV bridge. The original's Aliyun Drive, 115, Quark and Tianyi examples concern China-market services and eligible existing accounts; they are not universal purchase or account recommendations. Do not assume latency, overseas access or support based on the article's language.
| Workload | Suitability | Conditions |
|---|---|---|
| Large authorized downloads followed by upload | Conditional | Stage locally and verify remote completion; torrents can write non-sequentially |
| Occasional video/music reads | Often workable | Sequential access with sufficient cache and acceptable network delay |
| Website attachments and many small uploads | Evaluate carefully | Metadata/API requests, availability and consistency may dominate |
| Databases or application state | Avoid | Remote VFS does not replace local random I/O and database semantics |
| Installing software as on a second disk | Avoid as the default | Availability now depends on remote storage and APIs |
Prefer large mostly sequential files whose access can tolerate delay. For applications needing object APIs, see cloud drives versus object storage. A mount is one storage interface, not a substitute for every disk.
| Option | Capacity/cost basis | What to verify |
|---|---|---|
| Personal Google Drive | 15 GB free account storage; the original used 200 GB at roughly $30/year as a US budget example | Current country/account pricing, shared quota and API access; not a current worldwide quote |
| Google Workspace | Subscription/organization pooled quota | Do not assume unlimited space; administrator and plan policies apply |
| OneDrive | Eligible subscriptions may include 1 TB | Exact account allocation, throttling and allowed usage |
| Aliyun Drive | China-market account entitlement | The original's free-allocation estimate is unverified; no documented native rclone ali backend |
| Telegram | Messaging service, not a documented native rclone storage backend | No official telegram mount or free-storage promise in this procedure |
| 115/Tianyi and similar services | China-market account/driver conditions | Availability, permissions and API policy, without general performance guarantees |
| AList WebDAV bridge | Depends on its underlying storage | Driver support, authentication, gateway reliability and extra traffic |
The official backend overview lists Drive, OneDrive and WebDAV, but does not substantiate the original's Aliyun Drive/Telegram native-backend claims. Alibaba object storage accessed through S3 is a different product.
- Choose a documented backend available to your own account and location.
- Treat China-market providers as region-specific options for qualified users, not default international recommendations.
- Verify quotas and sustainable costs before relying on a free tier or an old unlimited-storage arrangement.
Review the official installer before executing it, or download a matching architecture binary from rclone.org when that source is unreachable:
# 官方一键脚本
curl https://rclone.org/install.sh | sudo bash
# 验证
rclone version
Plan the mount point, here /mnt/cloud. df -h reports the local filesystem; a cloud mount does not grow it.
sudo mkdir -p /mnt/cloud
Also confirm FUSE support and its device are available on the VPS; restricted container-based hosting may not permit mounts. Install the distribution's supported FUSE tools if needed.
A remote is rclone's named provider configuration:
rclone config
Choose n for a new remote:
- Select
drivefor Google Drive oronedrivefor OneDrive. The original labelsaliandtelegramare not verified native choices; a third-party bridge needs its own documented procedure. - For Drive, create your own OAuth client. The official Drive documentation states that rclone's shared client ID is being retired during 2026. Enable Drive API in Google's console, configure the OAuth consent screen and required scopes (such as drive/files.metadata.readonly), create the appropriate desktop client and enter its ID/secret. Use only the scopes required by your task and account policy.
- Follow the authorization flow shown by
rclone config. On a headless VPS, authorize from another device using the documented remote setup and transfer only the requested token/result privately; do not assume every provider uses an authorization code.
Test the configured remote before mounting:
rclone lsd mydrive: # mydrive 是刚才的 remote 名,列根目录
rclone size mydrive: # 看整个盘用量
Recursive size listings can consume time/API requests. Protect the configuration file because it contains credentials or tokens; configure it as the account that will run the service.
The mount subcommand presents the remote directory:
rclone mount mydrive: /mnt/cloud \
--vfs-cache-mode full \
--buffer-size 64M \
--dir-cache-time 72h \
--poll-interval 15s \
--daemon
| Mode | Behavior | Suitable use |
|---|---|---|
off | No disk VFS cache; application operations are limited | Compatible read-oriented tools |
writes | Written files use local staging | Uploads requiring seek/write behavior |
full | Local read and write cache | Many general file tools, with enough real disk |
With full, reads can be fetched in chunks and cached; it does not always download an entire file before returning data. Writes still need local staging and remote upload completion. Default cache commonly lives under ~/.cache/rclone. This is an option fragment to append to a mount command:
--cache-dir /mnt/cloud-cache
Put cache on a real local disk, outside the mount itself, with monitored limits and enough space. Its storage requirement is not new remote capacity. Dirty/pending files may prevent immediate cache eviction.
The buffer can help sequential reads but cannot overcome every remote limit. Original starting examples are 64M, 128M for large reads, or 32M on a 1 GB machine. Multiply by concurrent open files and include other memory consumers; bigger is not always better.
--dir-cache-time defaults to a short directory cache, commonly 5m; 72h reduces listings but can hide external changes longer. --poll-interval can discover changes on supporting backends. A 10–15-second interval increases requests and may be unnecessary. Polling does not work identically for all providers. Expect delayed visibility instead of local ext4 semantics.
--daemonruns a manual mount in the background.--daemonshould not be combined blindly with a service manager expecting a foreground process.--syslogsends logs to syslog; it is not service supervision. Use systemd for lifetime management.--max-read-aheadadjusts read-ahead where supported; measure before increasing it.--allow-otherpermits other users and--umask 022sets a mask. Grant only necessary access; unprivileged FUSE may require user_allow_other in its configuration.
Verify the mount:
df -h | grep cloud # 能看到一个容量很大的挂载点
ls /mnt/cloud # 能列出网盘内容
A large capacity displayed by the virtual mount is not proof of unlimited quota or successful durable writes.
The original service uses root and /usr/bin/rclone. Adapt it before use: prefer a dedicated account, verify the binary path, use that account's remote/config path and grant mount/cache access. Root will not automatically find a remote configured in another user's home. Type=notify requires support in the installed build; the service should run the mount in the foreground.
# /etc/systemd/system/rclone-mount.service
[Unit]
Description=rclone mount cloud drive
After=network-online.target
Wants=network-online.target
[Service]
Type=notify
User=root
ExecStart=/usr/bin/rclone mount mydrive: /mnt/cloud \
--vfs-cache-mode full \
--buffer-size 64M \
--dir-cache-time 72h \
--poll-interval 15s \
--allow-other
Restart=on-failure
RestartSec=10
[Install]
WantedBy=multi-user.target
sudo systemctl daemon-reload
sudo systemctl enable --now rclone-mount
sudo systemctl status rclone-mount
Restart=on-failure restarts an exited process, not every remote outage. network-online ordering helps boot sequencing but does not prove cloud API availability. Inspect logs and test remount/read/write behavior after a planned restart.
For eligible users of the China-market providers named in the original, AList or a compatible supported gateway can expose WebDAV. Its storage driver, credentials and terms are separate from rclone. The AList guide describes the bridge; this route is conditional, not the only possible integration.
115 / 夸克 / 天翼云
│ 在 AList 后台添加存储
▼
AList(对外提供 WebDAV,默认 http://localhost:5244/dav,用户名密码是 AList 的)
│ rclone 以 webdav 协议连接
▼
rclone mount → /mnt/cloud ← 你的 VPS 看上去多了块盘
In the original 115 example, app_key comes from that service's developer authorization. This applies only to an appropriately authorized account; it does not establish worldwide signup or API eligibility. Quark/Tianyi have their own driver and authorization rules. Changes can invalidate credentials or integrations.
Configure rclone's generic WebDAV remote:
rclone config
# 协议选 webdav
# url 填 http://127.0.0.1:5244/dav
# vendor 选 other
# user/pass 填 AList 的账号密码
The diagram's loopback endpoint assumes gateway and rclone share the host. For a remote gateway use authenticated HTTPS and a controlled network path, not plaintext public WebDAV. Test access before writing data.
For the original 1 vCPU/1 GB machine with a 20 GB local disk and a 200 GB Drive subscription:
- Local disk remains 20 GB, including OS and staging/cache.
- The separate remote allocation is 200 GB; it is not a 220 GB root filesystem. Count subscription, traffic/API costs and availability.
aria2c -d /mnt/cloud/torrentspoints downloads at a mount, but work can still stage locally. Confirm closed files finish uploading before deleting the only local copy.
Compare total cost with provider disk expansion and your acceptable delay, rather than assuming cloud storage is always cheaper.
API throttling: many small files create metadata/listing requests and can trigger 429 responses. Follow documented backoff, quotas and provider policy; large files still have transfer limits.
Cache exhaustion: --vfs-cache-mode full can stage large writes locally. A large upload may occupy most of the cache until transferred; monitor space and see full VPS disk recovery.
Filesystem semantics:
- Random access is generally unsuitable for database storage.
rm -rfon a remote tree can issue many individual deletions; validate paths and keep backups before destructive work.- Concurrent same-file writers, links and locking cannot be assumed to match local POSIX behavior.
Quota and account policy: Workspace/education arrangements do not imply unlimited entitlement. Even a paid account must follow its plan and API rules. See object-storage choices and self-hosted MinIO for other designs.
Docker: --allow-other can permit container users, but also expands local access. Match UID/GID, masks and mount propagation, and prevent a container from writing to an empty local directory if the remote mount failed.
- Workload tolerates sequential remote access and latency.
- Backend/bridge support is verified, rather than assuming ali or telegram exists.
-
--vfs-cache-mode fulluses a separate, monitored--cache-diron real disk. -
--buffer-sizeis budgeted for memory and concurrency, using 32M–128M only as examples. -
--dir-cache-timebalances request volume and freshness. - Service has
network-online.targetandRestart=on-failure, with account/config paths checked. -
--allow-otherand--umaskexpose only required users. - Cache disk/traffic alerts work: monitoring.
- Important data has a verified independent copy and restore drill; a mount alone is not a backup.
- Website/application objects: consider R2 or S3 with suitable APIs; storage, requests, CDN and transfer prices depend on the product, not a universal free-CDN promise.
- Databases: local SSD/block storage with consistent backups.
- Multi-device synchronization: Syncthing or a dedicated sync workflow, not an assumed concurrent shared filesystem.
A cloud mount works best when remote capacity is useful and latency, cache requirements and provider conditions are acceptable.