Tạo Proxy xoay với Python & Gunicorn trên VPS

Trong thế giới thu thập dữ liệu (web scraping), việc bị chặn IP là rào cản lớn nhất. Sử dụng proxy là giải pháp, nhưng quản lý hàng chục, hàng trăm proxy lại là một bài toán khác. Các dịch vụ proxy rotator thương mại tuy tiện lợi nhưng có thể tốn kém và thiếu linh hoạt.

Bài viết này sẽ hướng dẫn bạn cách xây dựng Proxy Rotator của riêng mình. Đây là giải pháp tối ưu, cho bạn toàn quyền kiểm soát, hiệu quả về chi phí, và có thể phục vụ nhiều dự án. Chúng ta sẽ đi từ việc tạo ra các proxy node cho đến xây dựng một hệ thống quản lý chuyên nghiệp.

Proxy Rotator là gì và tại sao bạn nên tự xây dựng?

Proxy Rotator là một hệ thống máy chủ thông minh, tự động thay đổi (xoay vòng) địa chỉ IP cho mỗi yêu cầu kết nối của bạn. Thay vì kết nối qua một proxy tĩnh duy nhất, hệ thống sẽ chuyển tiếp yêu cầu của bạn qua một “bể” (pool) gồm nhiều proxy khác nhau, giúp che giấu danh tính thực và tránh bị các website chặn do truy cập quá thường xuyên từ một IP.

Việc tự xây dựng hệ thống mang lại những lợi ích vượt trội so với việc sử dụng dịch vụ có sẵn:

• Toàn quyền kiểm soát: Bạn tự định nghĩa logic xoay vòng, cách kiểm tra “sức khỏe” proxy và các quy tắc retry, tối ưu cho nhu cầu cụ thể của mình.
• Chi phí hiệu quả: Tận dụng các VPS giá rẻ hoặc danh sách proxy có sẵn để xây dựng một hệ thống mạnh mẽ với chi phí thấp hơn nhiều so với dịch vụ thương mại.
• Tập trung hóa: Tạo ra một endpoint duy nhất cho toàn bộ team hoặc nhiều ứng dụng khác nhau, giúp đơn giản hóa việc quản lý và tích hợp.
• Bảo mật nâng cao: Danh sách proxy gốc của bạn được giữ kín ở phía máy chủ, không bị lộ ra ở phía client, tăng cường tính bảo mật cho toàn hệ thống.

Nền tảng hạ tầng – Tạo Proxy Nodes của riêng bạn

Trước khi có một hệ thống xoay vòng, chúng ta cần có chính các proxy. Phần này sẽ chỉ bạn cách biến những chiếc VPS thông thường thành các proxy server mạnh mẽ, tạo ra “nguyên liệu” đầu vào chất lượng cao cho hệ thống của chúng ta.

Lựa chọn công nghệ Proxy Server

Có nhiều cách để tạo một proxy server. Dưới đây là bảng so sánh 3 lựa chọn phổ biến và hiệu quả nhất để bạn đưa ra quyết định phù hợp.

Trong khuôn khổ bài viết, chúng ta sẽ chọn 3proxy vì sự cân bằng tuyệt vời giữa tính linh hoạt, hiệu năng và sự đơn giản của nó.

Hướng dẫn cài đặt 3proxy trên VPS Ubuntu một cách chuyên nghiệp

Chúng ta sẽ cài đặt 3proxy để tạo một proxy node hoàn chỉnh. Quy trình này tập trung vào tính bảo mật và sự ổn định cho môi trường production.

Bước 1: Biên dịch và cài đặt 3proxy từ mã nguồn

Kết nối vào VPS qua SSH. Sử dụng quy trình make install chuẩn để đảm bảo cài đặt đầy đủ và đúng vị trí.

sudo apt update && sudo apt install -y build-essential git openssl
git clone https://github.com/3proxy/3proxy.git
cd 3proxy
ln -s Makefile.Linux Makefile
make
sudo make install

Bước 2: Tạo mật khẩu mã hóa và cấu hình 3proxy

Lưu mật khẩu dưới dạng văn bản thuần là một rủi ro bảo mật lớn. Chúng ta sẽ tạo một mật khẩu đã được mã hóa bằng chuẩn crypt().

Chạy lệnh sau và nhập mật khẩu của bạn khi được hỏi. Lệnh này sẽ tạo ra một chuỗi đã mã hóa.

openssl passwd -1

Bạn sẽ nhận được một chuỗi ký tự dài, ví dụ: $1$abcdefgh$IJKLMNOPQRSTUVWXYZ.123. Hãy sao chép lại chuỗi này.

Bây giờ, tạo file cấu hình:

sudo nano /etc/3proxy/3proxy.cfg

Dán nội dung sau vào file. Lưu ý quan trọng:

1. Thay your_strong_username bằng tên người dùng của bạn.
2. Thay your_encrypted_password_hash bằng chuỗi mã hóa bạn vừa tạo.
3. Sử dụng tham số CR (Crypt) để chỉ định đây là mật khẩu đã mã hóa.

daemon
log /var/log/3proxy.log D
auth strong
users your_strong_username:CR:your_encrypted_password_hash
allow your_strong_username
proxy -p3128
socks -p1080

Bước 3: Chạy 3proxy với Systemd Service để đảm bảo ổn định

Để dịch vụ tự động khởi động cùng hệ thống và tự phục hồi khi có lỗi, chúng ta sẽ tạo một service cho systemd – trình quản lý dịch vụ tiêu chuẩn trên Linux.

Tạo file service:

sudo nano /etc/systemd/system/3proxy.service

Dán nội dung sau vào file:

[Unit]
Description=3Proxy Proxy Server
After=network.target

[Service]
ExecStart=/usr/local/bin/3proxy /etc/3proxy/3proxy.cfg
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Cuối cùng, kích hoạt và khởi động dịch vụ. Sử dụng tên file đầy đủ .service để đảm bảo tính chính xác tuyệt đối trên mọi hệ thống.

sudo systemctl daemon-reload
sudo systemctl enable 3proxy.service
sudo systemctl start 3proxy.service

Bước 4: Mở cổng firewall và kiểm tra

Cho phép truy cập vào các cổng proxy qua firewall ufw:

sudo ufw allow 3128
sudo ufw allow 1080

Từ máy tính cá nhân của bạn, dùng curl để xác nhận proxy đã hoạt động. Thay các thông tin tương ứng.

curl -x http://your_strong_username:your_plain_password@YOUR_VPS_IP:3128 http://httpbin.org/ip

Lưu ý quan trọng: Lệnh curl này sử dụng mật khẩu gốc (dạng văn bản thuần) của bạn để xác thực, không phải chuỗi đã được mã hóa mà bạn đã dán vào file cấu hình. 3proxy sẽ tự đối chiếu mật khẩu gốc này với chuỗi mã hóa trong file.

Nếu kết quả trả về là IP của VPS, bạn đã thành công! Lặp lại quy trình này trên nhiều VPS khác để xây dựng một “đội quân” proxy mạnh mẽ.

Bộ não điều khiển – Xây dựng Rotator API thông minh

Giờ bạn đã có các proxy node. Hãy cùng xây dựng Proxy Rotator API, một bộ não điều khiển trung tâm để quản lý và xoay vòng chúng một cách tự động.

Kiến trúc tổng quan và cấu trúc dự án

Hệ thống của chúng ta sẽ là một dịch vụ API tập trung. Dưới đây là cấu trúc thư mục và file proxies.json mẫu mà ứng dụng sẽ đọc.

rotator_project/
├── app/
│   ├── __init__.py
│   ├── main.py         # File API FastAPI
│   ├── rotator.py      # Lõi xử lý logic xoay vòng
│   └── checker.py      # Worker kiểm tra proxy
├── proxies.json        # File cấu hình danh sách proxy
├── requirements.txt
└── Dockerfile

File proxies.json mẫu

Tạo file này ở thư mục gốc của dự án và điền vào thông tin các proxy node bạn đã tạo ở Phần 1.

[
  {
    "id": "proxy_node_1",
    "url": "http://your_strong_username:your_plain_password@YOUR_VPS_IP_1:3128"
  },
  {
    "id": "proxy_node_2",
    "url": "http://your_strong_username:your_plain_password@YOUR_VPS_IP_2:3128"
  },
  {
    "id": "proxy_node_3",
    "url": "http://your_strong_username:your_plain_password@YOUR_VPS_IP_3:3128"
  }
]

Lập trình lõi xoay vòng nâng cao (rotator.py)

Đây là bộ não của hệ thống, chứa toàn bộ logic để lựa chọn, đánh giá và quản lý proxy. File này sẽ định nghĩa class ProxyRotator với các chiến lược đã nêu.

# app/rotator.py

import threading
import time
import random
from typing import List, Dict, Optional

class ProxyEntry:
    """Lớp chứa thông tin và trạng thái của một proxy."""
    def __init__(self, proxy_id: str, url: str):
        self.id = proxy_id
        self.url = url
        self.score = 50  # Điểm khởi tạo, từ 0-100
        self.last_used = 0
        self.last_checked = 0
        self.latency_ms = 9999
        self.is_alive = False

class ProxyRotator:
    """Quản lý proxy pool và thực hiện các chiến lược xoay vòng."""
    def __init__(self):
        self._lock = threading.Lock()
        self.pool: Dict[str, ProxyEntry] = {}
        # Dùng cho Sticky Session
        self.sticky_map: Dict[str, Dict[str, any]] = {}

    def load_proxies(self, proxy_list: List[Dict]):
        """Tải danh sách proxy từ file cấu hình."""
        with self._lock:
            for p in proxy_list:
                if p["id"] not in self.pool:
                    self.pool[p["id"]] = ProxyEntry(p["id"], p["url"])

    def update_proxy_status(self, check_results: List[Dict]):
        """Cập nhật trạng thái sống/chết và latency từ checker."""
        with self._lock:
            for result in check_results:
                for entry in self.pool.values():
                    if entry.url == result["url"]:
                        entry.is_alive = result["alive"]
                        entry.latency_ms = result["latency_ms"]
                        entry.last_checked = time.time()
                        break

    def get_next(self, strategy: str = "weighted", client_key: Optional[str] = None, sticky_seconds: int = 0) -> Optional[ProxyEntry]:
        """Lấy proxy tiếp theo dựa trên chiến lược được chọn."""
        now = time.time()
        with self._lock:
            # 1. Ưu tiên Sticky Session nếu có
            if client_key and client_key in self.sticky_map:
                sticky_info = self.sticky_map[client_key]
                if sticky_info["expiry_ts"] > now:
                    proxy = self.pool.get(sticky_info["proxy_id"])
                    if proxy and proxy.is_alive:
                        proxy.last_used = now
                        return proxy
                else:
                    del self.sticky_map[client_key]

            # 2. Lọc ra các proxy đang hoạt động
            alive_proxies = [p for p in self.pool.values() if p.is_alive]
            if not alive_proxies:
                return None

            # 3. Áp dụng chiến lược
            selected_proxy = None
            if strategy == "weighted":
                weights = [p.score for p in alive_proxies]
                selected_proxy = random.choices(alive_proxies, weights=weights, k=1)[0]
            else: # Mặc định hoặc Round-Robin
                alive_proxies.sort(key=lambda p: p.last_used)
                selected_proxy = alive_proxies[0]
            
            selected_proxy.last_used = now

            # 4. Gán Sticky Session nếu được yêu cầu
            if client_key and sticky_seconds > 0:
                self.sticky_map[client_key] = {
                    "proxy_id": selected_proxy.id,
                    "expiry_ts": now + sticky_seconds
                }
            
            return selected_proxy

    def mark_result(self, proxy_id: str, success: bool):
        """Đánh dấu kết quả sử dụng và cập nhật điểm số proxy."""
        with self._lock:
            proxy = self.pool.get(proxy_id)
            if not proxy:
                return
            if success:
                proxy.score = min(100, proxy.score + 1)
            else:
                proxy.score = max(0, proxy.score - 5)

Tối ưu hiệu năng với Worker Checker bất đồng bộ (checker.py)

Việc kiểm tra hàng loạt proxy rất tốn thời gian nếu làm tuần tự. Chúng ta sẽ sử dụng asyncio và aiohttp, các thư viện bất đồng bộ của Python, để thực hiện công việc này song song, giúp kiểm tra hàng trăm proxy chỉ trong vài giây.

# app/checker.py
import asyncio
import aiohttp
import time

async def check_proxy(session, proxy_url):
    start_time = time.monotonic()
    try:
        async with session.get("https://httpbin.org/ip", proxy=proxy_url, timeout=10) as resp:
            if resp.status == 200:
                latency = (time.monotonic() - start_time) * 1000
                return {"url": proxy_url, "alive": True, "latency_ms": latency}
    except Exception:
        pass
    return {"url": proxy_url, "alive": False, "latency_ms": float('inf')}

async def run_checks(proxy_list):
    async with aiohttp.ClientSession() as session:
        tasks = [check_proxy(session, p["url"]) for p in proxy_list]
        results = await asyncio.gather(*tasks)
        return results

Xây dựng bộ API đầy đủ với FastAPI (main.py)

Đây là lớp giao tiếp, nơi client sẽ tương tác với hệ thống. File này khởi tạo ứng dụng FastAPI và định nghĩa các endpoint /get_proxy, /report, /stats, và /health.

# app/main.py

import json
from fastapi import FastAPI, HTTPException, Query, Depends, Security
from fastapi.security import APIKeyHeader
from contextlib import asynccontextmanager
import asyncio

from .rotator import ProxyRotator
from .checker import run_checks

# Khởi tạo đối tượng rotator toàn cục
rotator = ProxyRotator()

# Cấu hình bảo mật API Key (tùy chọn)
API_KEY_NAME = "X-API-KEY"
api_key_header = APIKeyHeader(name=API_KEY_NAME, auto_error=True)
# Đặt API key của bạn vào đây, trong thực tế nên đọc từ biến môi trường
VALID_API_KEY = "YOUR_SECRET_API_KEY_HERE"

async def get_api_key(api_key: str = Security(api_key_header)):
    if api_key == VALID_API_KEY:
        return api_key
    else:
        raise HTTPException(status_code=403, detail="Could not validate credentials")

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Tải proxy từ file khi khởi động
    print("Loading proxies from file...")
    with open("proxies.json", "r") as f:
        proxy_list = json.load(f)
        rotator.load_proxies(proxy_list)
    
    # Chạy vòng lặp kiểm tra proxy nền
    asyncio.create_task(background_proxy_checker())
    yield

async def background_proxy_checker():
    """Tác vụ nền chạy định kỳ để kiểm tra sức khỏe proxy."""
    while True:
        print("Running background proxy check...")
        proxy_list_to_check = [{"id": p.id, "url": p.url} for p in rotator.pool.values()]
        results = await run_checks(proxy_list_to_check)
        rotator.update_proxy_status(results)
        print(f"Check complete. {sum(1 for p in rotator.pool.values() if p.is_alive)} proxies are alive.")
        await asyncio.sleep(300) # Chờ 5 phút cho lần kiểm tra tiếp theo

app = FastAPI(lifespan=lifespan)

# Thêm `dependencies=[Depends(get_api_key)]` vào các endpoint cần bảo mật
@app.get("/get_proxy", dependencies=[Depends(get_api_key)])
def get_proxy(
    client_key: Optional[str] = Query(None, description="Key định danh client cho Sticky Session"),
    sticky_seconds: int = Query(0, description="Thời gian (giây) để giữ proxy cho client_key")
):
    """Lấy một proxy tốt nhất từ pool."""
    proxy = rotator.get_next(client_key=client_key, sticky_seconds=sticky_seconds)
    if not proxy:
        raise HTTPException(status_code=503, detail="No healthy proxies available.")
    return {"id": proxy.id, "url": proxy.url}

@app.post("/report", dependencies=[Depends(get_api_key)])
def report_result(proxy_id: str, success: bool):
    """Client báo cáo kết quả sử dụng proxy."""
    rotator.mark_result(proxy_id, success=success)
    return {"status": "ok", "message": f"Reported result for proxy {proxy_id}"}

@app.get("/stats", dependencies=[Depends(get_api_key)])
def get_stats():
    """Lấy thông số của proxy pool."""
    with rotator._lock:
        total = len(rotator.pool)
        alive = sum(1 for p in rotator.pool.values() if p.is_alive)
        scores = {p.id: p.score for p in rotator.pool.values()}
    return {
        "total_proxies": total,
        "alive_proxies": alive,
        "proxy_scores": scores
    }

@app.get("/health")
def health_check():
    """Endpoint kiểm tra sức khỏe dịch vụ (không cần API key)."""
    return {"status": "healthy"}

Mở rộng: Bảo mật API với API Key

Để ngăn chặn việc lạm dụng dịch vụ, bạn nên bảo vệ các endpoint của mình bằng API key. FastAPI làm việc này rất dễ dàng thông qua hệ thống Dependency Injection. Đoạn code trên đã bao gồm một ví dụ cơ bản: client sẽ cần gửi một header X-API-KEY chứa key hợp lệ để có thể truy cập các endpoint quan trọng.

Vận hành & mở rộng – Triển khai lên production

Viết code xong chỉ là một nửa chặng đường. Để hệ thống hoạt động ổn định và an toàn, chúng ta cần triển khai nó một cách chuyên nghiệp.

Đóng gói ứng dụng với Docker

Docker giúp chúng ta đóng gói toàn bộ ứng dụng và các thư viện phụ thuộc vào một “container”.

Đầu tiên, hãy thêm gunicorn vào file requirements.txt của bạn.

fastapi
uvicorn
gunicorn
aiohttp

Sau đó, tạo một Dockerfile với nội dung sau:

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

# Sử dụng Gunicorn để quản lý các Uvicorn worker cho môi trường production
CMD ["gunicorn", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "main:app", "--bind", "0.0.0.0:8000"]

Lệnh CMD này sử dụng Gunicorn làm trình quản lý quy trình, chịu trách nhiệm khởi chạy và giám sát 4 Uvicorn worker. Đây là cách triển khai tiêu chuẩn, mang lại sự ổn định và hiệu năng cao.

Cấu hình Nginx làm Reverse Proxy và bảo mật với SSL

Chúng ta nên sử dụng Nginx làm reverse proxy. Nginx sẽ đứng phía trước, nhận request từ internet và chuyển tiếp đến container Gunicorn của chúng ta.

Nginx mang lại nhiều lợi ích:

• Tăng hiệu năng: Xử lý các kết nối tĩnh và chậm hiệu quả hơn.
• Cân bằng tải: Có thể phân phối request đến nhiều container nếu bạn mở rộng hệ thống.
• Bảo mật: Dễ dàng tích hợp SSL/TLS (HTTPS) bằng các công cụ như Certbot.

Dưới đây là một khối code mẫu tối giản cho file cấu hình của Nginx để bạn tham khảo.

server {
    listen 80;
    server_name your_domain_or_vps_ip;

    # Cấu hình cho SSL/TLS (HTTPS) với Certbot sẽ tự động thêm vào đây

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Ghi chú: Đoạn code trên là một ví dụ cơ bản. Để bật HTTPS, bạn nên sử dụng công cụ Certbot.

Tự động hóa và giám sát

Tương tự như 3proxy, bạn cũng nên tạo một systemd service cho container Docker của Rotator API. Việc này đảm bảo ứng dụng API của bạn sẽ tự động khởi động cùng hệ thống.

Bạn có thể tham khảo file .service mẫu dưới đây để quản lý container.

# Ví dụ file /etc/systemd/system/rotator-api.service
[Unit]
Description=Proxy Rotator API Docker Container
After=docker.service
Requires=docker.service

[Service]
ExecStart=/usr/bin/docker start -a your_container_name
ExecStop=/usr/bin/docker stop your_container_name
Restart=always

[Install]
WantedBy=multi-user.target

Ghi chú: Bạn cần tạo và chạy container Docker với tên your_container_name trước khi sử dụng service này.

Ngoài ra, việc viết một script monitor.py đơn giản để định kỳ gọi đến endpoint /health và /stats là rất cần thiết. Nếu có bất kỳ dấu hiệu bất thường nào, script có thể gửi cảnh báo qua email hoặc Telegram.

Các hướng mở rộng: Tích hợp Geo-targeting

Khi hệ thống đã hoạt động ổn định, bạn có thể dễ dàng mở rộng nó với các tính năng nâng cao như Geo-targeting.

Bằng cách tích hợp với một cơ sở dữ liệu GeoIP (như MaxMind GeoLite2), bạn có thể thêm một tham số vào API để yêu cầu một proxy từ một quốc gia cụ thể.

Câu hỏi thường gặp (FAQ)

1. So với việc sử dụng dịch vụ trả phí, giải pháp tự xây dựng có ưu nhược điểm gì?

Giải pháp tự xây dựng có ưu điểm lớn là toàn quyền kiểm soát, chi phí thấp hơn trong dài hạn và bảo mật cao hơn do bạn quản lý toàn bộ hạ tầng. Nhược điểm là bạn cần có kiến thức kỹ thuật để thiết lập và duy trì hệ thống, cũng như phải tự quản lý nguồn proxy.

2. Tôi có thể sử dụng hệ thống này cho những mục đích chính nào?

Hệ thống này rất lý tưởng cho các tác vụ cần nhiều địa chỉ IP khác nhau như: thu thập dữ liệu web (web scraping), nghiên cứu thị trường, xác minh quảng cáo (ad verification), quản lý nhiều tài khoản mạng xã hội, và kiểm thử ứng dụng từ các vị trí địa lý khác nhau.

3. Chi phí để tự xây dựng hệ thống này là bao nhiêu?

Chi phí chính là tiền thuê các VPS để làm proxy node và một VPS để chạy API rotator. Phần mềm chúng ta sử dụng (Linux, Python, 3proxy, Docker, Nginx) đều là mã nguồn mở và miễn phí. Do đó, tổng chi phí sẽ phụ thuộc vào số lượng và loại VPS bạn thuê.

4. Hệ thống này có thể xử lý bao nhiêu yêu cầu mỗi giây?

Hiệu năng của hệ thống phụ thuộc vào nhiều yếu tố: cấu hình VPS (CPU, RAM), băng thông mạng, số lượng Gunicorn worker, và độ trễ của các proxy node. Với một VPS tầm trung và các proxy chất lượng, hệ thống có thể dễ dàng xử lý hàng trăm đến hàng nghìn yêu cầu mỗi phút và có thể mở rộng bằng cách tăng số worker hoặc chạy trên nhiều server.

5. Làm thế nào để thêm proxy từ một quốc gia cụ thể (Geo-targeting)?

Bạn cần tích hợp một thư viện GeoIP (ví dụ geoip2 của Python) và một file CSDL GeoIP (như GeoLite2-Country.mmdb từ MaxMind). Trong file rotator.py, bạn sẽ viết một hàm để lọc danh sách proxy alive_proxies dựa trên mã quốc gia được yêu cầu trước khi áp dụng chiến lược xoay vòng.

6. Tại sao bài viết lại chọn FastAPI thay vì Flask?

FastAPI được chọn vì hiệu năng vượt trội và hỗ trợ lập trình bất đồng bộ (async) ngay từ đầu. Điều này rất quan trọng cho một ứng dụng xử lý nhiều tác vụ mạng như kiểm tra và chuyển tiếp proxy. FastAPI giúp hệ thống hoạt động hiệu quả và nhanh hơn.

7. Sử dụng proxy tự tạo trên VPS có an toàn không?

Có, nếu bạn tuân thủ các phương pháp bảo mật tốt nhất được nêu trong bài viết. Việc sử dụng mật khẩu đã mã hóa, bật firewall, quản lý dịch vụ bằng systemd và bảo vệ API bằng key sẽ tạo ra một hệ thống an toàn và chỉ bạn mới có thể truy cập.

Kết luận

Việc xây dựng Proxy Rotator của riêng bạn là một dự án đầy thử thách nhưng mang lại giá trị to lớn. Nó cho bạn sự kiểm soát, linh hoạt và kiến thức sâu sắc về cách các hệ thống mạng hoạt động.

• Lưu ý về bảo mật: Luôn sử dụng mật khẩu mạnh, đã mã hóa cho các proxy node và bật firewall trên VPS. Bảo mật API rotator bằng API key để ngăn chặn việc sử dụng trái phép.
• Lưu ý về pháp lý: Luôn tuân thủ điều khoản dịch vụ của các trang web bạn thu thập dữ liệu và các quy định pháp luật hiện hành. Sử dụng proxy một cách có trách nhiệm.

Chúc bạn thành công!

Tài liệu tham khảo

• GitHub – 3proxy/3proxy: 3proxy – tiny free proxy server
• FastAPI
• Gunicorn – Python WSGI HTTP Server for UNIX
• Dockerfile reference | Docker Docs
• nginx documentation
• Manage Systemd Services with systemctl on Linux | DigitalOcean
• asyncio — Asynchronous I/O — Python 3.14.0 documentation