⚡ 9-in-1 Cloud Storage Gateway

The Unified Multi-Cloud Storage Pooling & Intelligent Stream Gateway

Aggregate up to 9 Google Drive & S3 cloud accounts into one seamless, high-performance virtual storage pool with zero server disk buffering.

9-in-1 Cloud is a specialized, open-source reverse-proxy storage gateway and virtualization layer built for developers, homelab operators, and power users. It connects and aggregates up to 9 Google Drive accounts (15 GB each = 135.00 GB free) plus enterprise S3 buckets (Cloudflare R2, MinIO, Wasabi, or AWS S3) into a single unified virtual storage pool with zero server disk buffering.

⚡ The Problem Solved

Managing multiple cloud accounts usually requires juggling browser profiles, switching accounts, and dealing with storage imbalances where one drive sits empty while another overflows. Typical VPS gateway solutions write entire files onto the host disk before uploading to cloud storage, risking disk exhaustion, slow I/O bottlenecks, and VPS failure.

🚀 The 9-in-1 Cloud Solution

1. 135 GB+ Free Unified Pool: Immediately unites 9 free Google Drive accounts into a single massive 135 GB virtual storage pool.
2. Zero-Buffering Direct Stream: Files pipe directly from the client socket through Node.js stream buffers into Google Drive API v3 without writing a single byte to the VPS server hard drive.
3. Dynamic Load Balancing: Real-time quota detection automatically routes incoming files to the account with the most remaining space.
4. Relational Virtual Directory: A single unified MySQL or SQLite virtual file system hierarchy gives you complete folder trees, tags, search, and instant shareable streaming links.

flowchart TD
    subgraph Clients["Clients & Ingestion Sources"]
        UI["Web Dashboard (React 19 + Material 3)"]
        CLI["CLI Scripts / cURL Direct Stream"]
        APP["Third-Party Software (API Key Auth)"]
    end

    subgraph GatewayCore["9-in-1 Cloud Gateway Server (Node.js 20+ Express 5)"]
        AUTH["Authentication & Token Guard\n(JWT Bearer / Argon2 / SHA-256 API Keys)"]
        DISPATCH["Intelligent Dispatcher & Load Balancer\n(Space-Aware / Round-Robin / Priority)"]
        STREAM["Direct Memory Stream Engine (Busboy)\nZero Bytes Written to Host Hard Drive"]
        VFS["Virtual File System Schema\n(Folder Hierarchy, Tags, Quota Stats)"]
    end

    subgraph StorageCloud["Distributed Multi-Cloud Storage Matrix"]
        GD1["Google Drive #1 (15 GB)"]
        GD2["Google Drive #2 (15 GB)"]
        GD3["Google Drive #3 (15 GB)"]
        GD4["Google Drive #4 (15 GB)"]
        GD5["Google Drive #5 (15 GB)"]
        GD6["Google Drive #6 (15 GB)"]
        GD7["Google Drive #7 (15 GB)"]
        GD8["Google Drive #8 (15 GB)"]
        GD9["Google Drive #9 (15 GB)"]
        S3B["Enterprise S3 (Cloudflare R2 / MinIO / AWS)"]
    end

    subgraph Database["Metadata Persistence"]
        DB[(MySQL / SQLite Database)]
    end

    UI --> AUTH
    CLI --> AUTH
    APP --> AUTH

    AUTH --> DISPATCH
    DISPATCH --> STREAM
    STREAM --> VFS
    VFS <--> DB

    STREAM -- Direct In-Memory Stream Chunking --> GD1
    STREAM -- Direct In-Memory Stream Chunking --> GD2
    STREAM -- Direct In-Memory Stream Chunking --> GD3
    STREAM -- Direct In-Memory Stream Chunking --> GD4
    STREAM -- Direct In-Memory Stream Chunking --> GD5
    STREAM -- Direct In-Memory Stream Chunking --> GD6
    STREAM -- Direct In-Memory Stream Chunking --> GD7
    STREAM -- Direct In-Memory Stream Chunking --> GD8
    STREAM -- Direct In-Memory Stream Chunking --> GD9
    STREAM -- S3 Multipart Upload --> S3B

Loading

🌊 The Stream Pipeline Lifecycle:

1. Client issues a POST /files/upload multipart stream.
2. Express pipes request chunks into Busboy on the fly.
3. The Intelligent Dispatcher queries remaining capacities across all 9 connected accounts.
4. An active OAuth2 client is retrieved (refreshing access tokens automatically if near expiration).
5. File chunks pipe directly into Google Drive API v3 drive.files.create({ media: { body: fileStream } }).
6. Zero bytes of the uploaded file are saved to the server's local hard drive. The file streams straight from the client socket into Google's cloud servers.
7. Upon completion, Google returns the remote file ID and size, which is recorded in the MySQL VFS metadata layer.

📊 Real-Time Quota Tracker & Space Matrix Track combined 135 GB storage meters, individual drive capacities, and real-time distribution stats.

🗂️ Virtual File System & 4K Media Showcase Browse unified folders, search across accounts, stream 4K videos, and preview wallpapers with Liquid Glass.

🐳 Option A: One-Click Docker Compose (Recommended)

1. Clone the repository:

   git clone https://github.com/smartworldarafath/9-in-1-Cloud.git
   cd 9-in-1-Cloud

2. Configure environment settings:

   cp .env.docker.example .env
   # Edit .env with your JWT secret, database credentials, and encryption key

3. Launch the entire stack:

   docker compose up -d --build

4. Access your dashboard:

   • Web Dashboard: http://localhost:3000
   • Gateway REST API: http://localhost:5000/api

---

💻 Option B: Manual Host Setup

Prerequisites:

• Node.js: v20.x LTS or higher
• MySQL: 8.0+ (or SQLite)
• Google Cloud Console: OAuth2 Client credentials (client_id, client_secret)

1. Backend Gateway Setup:

cd backend
npm install
cp .env.example .env
npx prisma migrate deploy
npm run build
npm start

2. Frontend Web Dashboard:

cd frontend
npm install
npm run build
npm start

Upload and stream files headlessly from backup scripts, automated microservices, and CI/CD pipelines.

1. Stream Upload via cURL:

curl -X POST "http://localhost:5000/api/files/upload" \
  -H "Authorization: Bearer <API_KEY_OR_JWT>" \
  -F "file=@/path/to/archive.tar.gz" \
  -F "folderId=optional-virtual-folder-id"

2. Ingestion Script in Node.js:

import fs from 'fs';
import FormData from 'form-data';
import axios from 'axios';

const form = new FormData();
form.append('file', fs.createReadStream('./dataset.zip'));

const response = await axios.post('http://localhost:5000/api/files/upload', form, {
  headers: {
    ...form.getHeaders(),
    'Authorization': 'Bearer YOUR_API_KEY'
  },
  maxBodyLength: Infinity,
  maxContentLength: Infinity
});

console.log('Pooled File Uploaded:', response.data);

3. Python Stream Ingestion:

import requests

with open('large_model.bin', 'rb') as f:
    files = {'file': f}
    headers = {'Authorization': 'Bearer YOUR_API_KEY'}
    res = requests.post('http://localhost:5000/api/files/upload', files=files, headers=headers)
    print(res.json())

If 9-in-1 Cloud saved you cloud storage costs, helped your homelab, or inspired your architecture, please consider supporting the project:

SupportKori Cards / bKash / Nagad supportkori.com/arafathrahman

nsave Ntag: @arafath_rahman9 Account: Md Arafath Rahman

RedotPay Account ID: 1965421414

Payoneer Email: arafathrahman710@gmail.com Customer ID: 70366820

Method	Details & Direct Links
SupportKori	supportkori.com/arafathrahman (bKash, Nagad, Visa, Mastercard)
nsave	Ntag: @arafath_rahman9 · Account: Md Arafath Rahman
RedotPay	Account ID: 1965421414
Payoneer	Email: arafathrahman710@gmail.com · Customer ID: 70366820

9-in-1 Cloud is open-source software licensed under the Apache License, Version 2.0.

Copyright © 2026 Arafath Rahman and Contributors.

• Icons & Design Inspiration: Google Material 3 Expressive, Material Symbols, and Lucide Icons.
• Storage Protocols: Google Drive API v3, AWS SDK v3 Client-S3, and Busboy Stream Duplexing.

_{Search terms: 9-in-1 Cloud, multi-cloud storage pooling, Google Drive aggregator, zero disk VPS proxy, S3 gateway, free cloud storage pooling, Material 3 Expressive, Docker cloud drive, Node.js stream upload.}