📌 در پایان این پروژه خواهیم داشت:

🔹 سرویس انتقال فایل با لینک موقت و تاریخ انقضا

🔹 Origin Server برای فایل‌های اصلی

🔹 Edge Cache با Nginx

🔹 کش خودکار CSS، JS، فونت و فایل‌های استاتیک

🔹 Image CDN با Resize و Crop لحظه‌ای

🔹 خروجی WebP و AVIF

🔹 URL امضاشده برای جلوگیری از سوءاستفاده از Image Processor

🔹 امکان ساخت چند Edge در ایران و خارج

                    +----------------+
                    | Origin Server  |
                    |  Files/Images  |
                    +--------+-------+
                             |
             +---------------+---------------+
             |                               |
             v                               v
     +---------------+               +---------------+
     | Edge - Iran   |               | Edge - Europe |
     | Nginx Cache   |               | Nginx Cache   |
     +-------+-------+               +-------+-------+
             |                               |
             v                               v
       Iranian Users                   Other Users

ساخت CDN شخصی با چند VPS ایرانیکاسرور

برای شروع می‌توانید Origin را روی یک سرور مجازی ایران قرار دهید و در صورت نیاز Edgeهای دیگر را روی VPSهای جداگانه بسازید. اگر کاربران شما هم داخل و هم خارج ایران هستند، جدا کردن Edge ایران و خارج می‌تواند Architecture مناسبی برای آزمایش CDN شخصی باشد.

sudo apt update
sudo apt upgrade -y

sudo apt install 
  nginx 
  python3 
  python3-venv 
  python3-pip 
  sqlite3 
  curl 
  ca-certificates 
  -y

sudo mkdir -p /srv/file-platform/static
sudo mkdir -p /srv/file-platform/images
sudo mkdir -p /srv/file-platform/transfers
sudo mkdir -p /opt/file-platform

cd /opt/file-platform

python3 -m venv venv

./venv/bin/pip install 
  fastapi 
  "uvicorn[standard]" 
  python-multipart

nano /opt/file-platform/app.py

import hashlib
import os
import secrets
import sqlite3
import time
import uuid

from pathlib import Path
from urllib.parse import quote

from fastapi import (
    FastAPI,
    File,
    Form,
    Header,
    HTTPException,
    UploadFile,
)

from fastapi.responses import Response


app = FastAPI()

BASE_URL = os.getenv(
    "BASE_URL",
    "https://transfer.example.com"
).rstrip("/")

ADMIN_KEY = os.getenv(
    "ADMIN_KEY",
    "CHANGE-ME"
)

FILE_ROOT = Path(
    "/srv/file-platform/transfers"
).resolve()

DB_PATH = Path(
    "/opt/file-platform/transfers.db"
)

MAX_BYTES = 5 * 1024 * 1024 * 1024


def db():
    conn = sqlite3.connect(DB_PATH)
    conn.row_factory = sqlite3.Row
    return conn


def init_db():
    conn = db()

    conn.execute("""
        CREATE TABLE IF NOT EXISTS transfers (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            token_hash TEXT UNIQUE NOT NULL,
            stored_name TEXT NOT NULL,
            original_name TEXT NOT NULL,
            expires_at INTEGER NOT NULL,
            created_at INTEGER NOT NULL
        )
    """)

    conn.commit()
    conn.close()


def token_hash(token):
    return hashlib.sha256(
        token.encode()
    ).hexdigest()


init_db()


@app.post("/api/upload")
async def upload_file(
    file: UploadFile = File(...),
    ttl_minutes: int = Form(60),
    x_admin_key: str | None = Header(None),
):
    if not secrets.compare_digest(
        x_admin_key or "",
        ADMIN_KEY
    ):
        raise HTTPException(
            status_code=401,
            detail="Unauthorized"
        )

    if ttl_minutes < 1 or ttl_minutes > 10080:
        raise HTTPException(
            status_code=400,
            detail="Invalid TTL"
        )

    original = Path(
        file.filename or "file.bin"
    ).name

    suffix = Path(original).suffix[:16]

    stored = (
        uuid.uuid4().hex
        + suffix
    )

    temp_path = FILE_ROOT / (
        stored + ".part"
    )

    final_path = FILE_ROOT / stored

    total = 0

    try:
        with temp_path.open("wb") as output:
            while True:
                chunk = await file.read(
                    1024 * 1024
                )

                if not chunk:
                    break

                total += len(chunk)

                if total > MAX_BYTES:
                    raise HTTPException(
                        status_code=413,
                        detail="File too large"
                    )

                output.write(chunk)

        temp_path.rename(final_path)

    except Exception:
        temp_path.unlink(
            missing_ok=True
        )
        raise

    token = secrets.token_urlsafe(32)
    digest = token_hash(token)

    now = int(time.time())

    expires = (
        now
        + ttl_minutes * 60
    )

    conn = db()

    conn.execute("""
        INSERT INTO transfers (
            token_hash,
            stored_name,
            original_name,
            expires_at,
            created_at
        )
        VALUES (?, ?, ?, ?, ?)
    """, (
        digest,
        stored,
        original,
        expires,
        now
    ))

    conn.commit()
    conn.close()

    return {
        "url": f"{BASE_URL}/t/{token}",
        "expires_at": expires,
        "size": total,
    }


@app.get("/t/{token}")
def download(token: str):
    digest = token_hash(token)
    now = int(time.time())

    conn = db()

    row = conn.execute("""
        SELECT
            stored_name,
            original_name,
            expires_at
        FROM transfers
        WHERE token_hash = ?
    """, (digest,)).fetchone()

    conn.close()

    if row is None:
        raise HTTPException(
            status_code=404
        )

    if row["expires_at"] <= now:
        raise HTTPException(
            status_code=410,
            detail="Link expired"
        )

    response = Response(
        status_code=200
    )

    response.headers[
        "X-Accel-Redirect"
    ] = (
        "/_transfer/"
        + quote(row["stored_name"])
    )

    response.headers[
        "Content-Disposition"
    ] = (
        "attachment; "
        "filename*=UTF-8''"
        + quote(row["original_name"])
    )

    response.headers[
        "Cache-Control"
    ] = "private, no-store"

    response.headers[
        "X-Robots-Tag"
    ] = "noindex, nofollow, noarchive"

    return response

openssl rand -hex 32

sudo nano \
/etc/systemd/system/file-transfer.service

[Unit]
Description=Temporary File Transfer API
After=network.target

[Service]
WorkingDirectory=/opt/file-platform

Environment="BASE_URL=https://transfer.example.com"
Environment="ADMIN_KEY=YOUR_RANDOM_ADMIN_KEY"

ExecStart=/opt/file-platform/venv/bin/uvicorn 
    app:app 
    --host 127.0.0.1 
    --port 9000 
    --workers 2

Restart=on-failure
RestartSec=3

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now file-transfer
sudo systemctl status file-transfer

server {
    listen 80;
    server_name transfer.example.com;

    client_max_body_size 5g;

    location /api/ {
        proxy_request_buffering off;

        proxy_pass http://127.0.0.1:9000;

        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    location /t/ {
        proxy_pass http://127.0.0.1:9000;

        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    location /_transfer/ {
        internal;

        alias /srv/file-platform/transfers/;

        add_header X-Content-Type-Options nosniff always;
    }
}

curl -X POST \
  -H "X-Admin-Key: YOUR_RANDOM_ADMIN_KEY" \
  -F "ttl_minutes=120" \
  -F "file=@backup.zip" \
  https://transfer.example.com/api/upload

{
  "url": "https://transfer.example.com/t/....",
  "expires_at": 1790960000,
  "size": 52428800
}

server {
    listen 80;
    server_name origin.example.com;

    location /static/ {
        alias /srv/file-platform/static/;

        autoindex off;

        expires 7d;

        add_header Cache-Control \
            "public, max-age=604800, immutable";
    }

    location /images/ {
        alias /srv/file-platform/images/;

        autoindex off;

        expires 30d;

        add_header Cache-Control \
            "public, max-age=2592000, immutable";
    }
}

app.4f87c2.css
app.v17.js
logo.20261002.svg

sudo apt update
sudo apt install nginx -y

proxy_cache_path \
  /var/cache/nginx/static \
  levels=1:2 \
  keys_zone=STATIC_CACHE:50m \
  max_size=20g \
  inactive=7d \
  use_temp_path=off;

server {
    listen 80;
    server_name cdn.example.com;

    location / {
        proxy_cache STATIC_CACHE;

        proxy_cache_key \
            "$scheme$proxy_host$request_uri";

        proxy_cache_lock on;

        proxy_cache_valid 200 301 302 7d;
        proxy_cache_valid 404 1m;

        proxy_cache_use_stale \
            error \
            timeout \
            updating \
            http_500 \
            http_502 \
            http_503 \
            http_504;

        proxy_pass \
            https://origin.example.com;

        proxy_set_header \
            Host origin.example.com;

        proxy_ssl_server_name on;

        add_header \
            X-Cache-Status \
            $upstream_cache_status \
            always;
    }
}

curl -I \
https://cdn.example.com/static/app.v1.js

X-Cache-Status: MISS

X-Cache-Status: HIT

ir-edge.example.com
eu-edge.example.com
cdn.example.com

120x120   avatar
400x300   card
800x600   article
1600x900  hero

sudo apt update
sudo apt install ca-certificates curl -y

sudo install -m 0755 
  -d /etc/apt/keyrings

sudo curl -fsSL 
  https://download.docker.com/linux/ubuntu/gpg 
  -o /etc/apt/keyrings/docker.asc

sudo chmod a+r 
  /etc/apt/keyrings/docker.asc

sudo tee 
/etc/apt/sources.list.d/docker.sources 
>/dev/null <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update

sudo apt install 
  docker-ce 
  docker-ce-cli 
  containerd.io 
  docker-buildx-plugin 
  docker-compose-plugin 
  -y

openssl rand -hex 32
openssl rand -hex 32

sudo mkdir -p /opt/imgproxy
cd /opt/imgproxy

IMGPROXY_KEY=YOUR_HEX_KEY
IMGPROXY_SALT=YOUR_HEX_SALT
IMGPROXY_SIGNATURE_SIZE=32
IMGPROXY_AUTO_WEBP=true
IMGPROXY_AUTO_AVIF=true

services:
  imgproxy:
    image: ghcr.io/imgproxy/imgproxy:latest

    restart: unless-stopped

    ports:
      - "127.0.0.1:8080:8080"

    env_file:
      - .env

sudo docker compose up -d

sudo docker compose ps

/srv/file-platform/images/product.jpg

https://origin.example.com/images/product.jpg

/SIGNATURE/rs:fill:800:600/plain/SOURCE_URL@webp

import base64
import hashlib
import hmac


KEY = bytes.fromhex(
    "YOUR_HEX_KEY"
)

SALT = bytes.fromhex(
    "YOUR_HEX_SALT"
)


source = (
    "https://origin.example.com"
    "/images/product.jpg"
)

encoded_source = (
    base64.urlsafe_b64encode(
        source.encode()
    )
    .rstrip(b"=")
    .decode()
)

path = (
    "/rs:fill:800:600:0"
    f"/{encoded_source}.webp"
)

digest = hmac.new(
    KEY,
    SALT + path.encode(),
    hashlib.sha256
).digest()

signature = (
    base64.urlsafe_b64encode(
        digest
    )
    .rstrip(b"=")
    .decode()
)

print(
    "https://img.example.com/"
    + signature
    + path
)

proxy_cache_path \
  /var/cache/nginx/images \
  levels=1:2 \
  keys_zone=IMAGE_CACHE:100m \
  max_size=30g \
  inactive=30d \
  use_temp_path=off;

server {
    listen 80;
    server_name img.example.com;

    location / {
        proxy_cache IMAGE_CACHE;

        proxy_cache_key \
            "$scheme$host$request_uri";

        proxy_cache_lock on;

        proxy_cache_valid 200 30d;
        proxy_cache_valid 404 1m;

        proxy_cache_use_stale \
            error \
            timeout \
            updating;

        proxy_pass \
            http://127.0.0.1:8080;

        add_header \
            X-Image-Cache \
            $upstream_cache_status \
            always;
    }
}

product-800x600.webp
product-800x600.avif

<img
  src="IMAGE_800_URL"
  srcset="
    IMAGE_400_URL 400w,
    IMAGE_800_URL 800w,
    IMAGE_1200_URL 1200w
  "
  sizes="(max-width: 600px) 100vw, 800px"
  loading="lazy"
  alt="Product image"
/>

✅ Origin را تا حد امکان فقط برای Edgeها باز کنید.

✅ HTTPS را روی Origin و Edge فعال کنید.

✅ Upload API را بدون Authentication عمومی نکنید.

✅ Tokenهای انتقال فایل را طولانی و تصادفی بسازید.

✅ URLهای imgproxy را Sign کنید.

✅ فایل‌های موقت منقضی‌شده را خودکار پاک کنید.

✅ روی Cache Disk فضای آزاد را مانیتور کنید.

✅ Docker Container را مستقیماً روی IP عمومی Publish نکنید.

/static/app.js

/static/app.92db18.js

برای ساخت Origin، Edge یا دانلودسنتر به VPS نیاز دارید؟

می‌توانید Origin را روی VPS ایران قرار دهید و برای تست معماری Multi-Edge از سرورهای مجازی دیگر استفاده کنید. اگر در انتخاب منابع، Nginx Cache، Docker یا شبکه میان Edgeها مشکل دارید، امکان درخواست کانفیگ نیز وجود دارد.

📌 تماس با پشتیبانی:
021-91302460
| ایرانیکاسرور

جمع‌بندی

با ترکیب Nginx، Python و imgproxy می‌توان یک زیرساخت شخصی برای تحویل فایل ساخت که سه نیاز متفاوت را پوشش دهد: فایل‌های موقت، Assetهای استاتیک و تصاویر بهینه‌شده.

FastAPI مسئول صدور لینک‌های موقت است، Nginx فایل‌های استاتیک را روی Edge Cache می‌کند و imgproxy نسخه‌های مختلف تصویر را فقط هنگام نیاز می‌سازد. با Cache کردن خروجی imgproxy نیز پردازش تکراری تصویر به حداقل می‌رسد.

اگر فقط یک Node داشته باشید، معماری شما هنوز بیشتر شبیه Origin + Cache Server است. با اضافه کردن Edge در چند نقطه و مسیریابی کاربران به Edge مناسب، این ساختار به یک CDN شخصی واقعی نزدیک می‌شود.

برای پروژه‌های داخلی، سرویس‌های سازمانی، دانلودسنتر، فروش فایل یا سایت‌هایی که کنترل کامل روی داده و Cache برایشان مهم است، این معماری می‌تواند جایگزین جذابی برای قرار دادن تمام فایل‌ها روی همان وب‌سرور اصلی باشد.

منابع رسمی

مستندات رسمی Nginx Proxy Cache

مستندات internal و X-Accel-Redirect در Nginx

Nginx Slice Module برای فایل‌های بزرگ

مستندات رسمی FastAPI برای Upload فایل

مستندات رسمی imgproxy

راهنمای رسمی نصب Docker Engine روی Ubuntu