Cách Xoay Proxy Trong Python: Requests, Retry Và Quản Lý Proxy Pool

Xoay proxy trong Python là quá trình chọn một proxy khác cho từng request hoặc từng phiên làm việc. Với thư viện Requests, cách đơn giản nhất là lưu danh sách proxy, chọn một endpoint trước mỗi lần gọi và truyền nó qua tham số proxies. Một hệ thống dùng thực tế còn cần timeout, xác thực, retry có giới hạn, kiểm tra trạng thái và tạm loại proxy đang lỗi.

Ví dụ tối giản:

import random
import requests

proxy_pool = [
    "http://HOST_1:PORT_1",
    "http://HOST_2:PORT_2",
    "http://HOST_3:PORT_3",
]

proxy_url = random.choice(proxy_pool)
proxies = {
    "http": proxy_url,
    "https": proxy_url,
}

response = requests.get(
    "https://httpbin.org/ip",
    proxies=proxies,
    timeout=(5, 20),
)
response.raise_for_status()
print(response.json())

Đoạn code trên đủ để hiểu cú pháp nhưng chưa phù hợp với hệ thống production. Nếu proxy được chọn không kết nối được, request sẽ thất bại. Nếu chọn ngẫu nhiên, một proxy có thể được dùng nhiều lần liên tiếp. Bài viết dưới đây sẽ xây dựng cách xoay proxy ổn định hơn và giải thích khi nào nên giữ nguyên IP thay vì thay đổi liên tục.

Chỉ sử dụng proxy và tự động hóa với website, API hoặc dữ liệu mà bạn được phép truy cập. Cần tuân thủ điều khoản dịch vụ, giới hạn tần suất, quyền riêng tư và pháp luật liên quan.

Xoay proxy trong Python là gì?

Proxy rotation nghĩa là phân phối các request qua nhiều địa chỉ proxy thay vì để toàn bộ lưu lượng đi qua một IP duy nhất. Việc chọn IP có thể diễn ra trong code Python hoặc được nhà cung cấp xử lý sau một gateway chung.

Có hai mô hình chính:

Mô hình Cách hoạt động Trách nhiệm của ứng dụng
Xoay phía client Python giữ danh sách và chọn proxy Quản lý danh sách, health check, retry và loại proxy lỗi
Xoay phía nhà cung cấp Python kết nối vào một gateway; hệ thống phía sau chọn IP Quản lý session và gửi request đúng endpoint

Xoay phía client cho phép kiểm soát proxy nào được dùng, số lần sử dụng và thời gian cooldown. Đổi lại, code phức tạp hơn. Rotating gateway giảm phần quản lý danh sách, nhưng quy tắc đổi IP phụ thuộc nhà cung cấp: theo request, theo kết nối hoặc theo thời gian.

Nếu chưa rõ proxy chuyển tiếp request như thế nào, hãy xem bài proxy là gì trước khi triển khai.

Khi nào nên xoay proxy và khi nào nên giữ IP?

Proxy rotation phù hợp với các request độc lập, chẳng hạn kiểm tra nội dung công khai theo nhiều vị trí, giám sát kết quả hiển thị hoặc xử lý danh sách URL không chia sẻ trạng thái đăng nhập.

Không nên đổi IP giữa một quy trình nhiều bước cần duy trì cookie và phiên. Đăng nhập, thêm sản phẩm vào giỏ, gửi biểu mẫu nhiều bước hoặc làm việc với một phiên người dùng thường cần sticky session. Nếu IP đổi ở giữa quy trình, hệ thống đích có thể yêu cầu xác minh lại hoặc làm mất tính nhất quán.

Quy tắc dễ nhớ:

  • Request độc lập có thể dùng rotation theo request.

  • Nhiều bước thuộc cùng một phiên nên giữ một proxy.

  • Công việc theo khu vực cần giữ IP và vị trí địa lý nhất quán.

  • Retry không nên tự động đổi IP nếu request có thể tạo tác dụng phụ, chẳng hạn thanh toán hoặc ghi dữ liệu.

Chuẩn bị môi trường Python

Cài thư viện Requests trong virtual environment:

python -m venv .venv

Kích hoạt môi trường rồi cài package:

python -m pip install requests

Nếu cần SOCKS4 hoặc SOCKS5, cài phần mở rộng SOCKS:

python -m pip install "requests[socks]"

Thông tin proxy thường gồm protocol, host, port và có thể có username/password:

http://HOST:PORT
http://USERNAME:PASSWORD@HOST:PORT
socks5h://USERNAME:PASSWORD@HOST:PORT

Với SOCKS5, socks5h:// yêu cầu phân giải hostname qua proxy, giúp tránh việc DNS được phân giải cục bộ ngoài ý muốn. Khả năng hỗ trợ còn phụ thuộc proxy và môi trường mạng.

Cách dùng một proxy với Python Requests

Requests nhận cấu hình proxy qua dictionary. Khóa http và https nói lên loại URL đích; giá trị là proxy được dùng để chuyển tiếp request.

import requests

proxy_url = "http://USERNAME:PASSWORD@HOST:PORT"

proxies = {
    "http": proxy_url,
    "https": proxy_url,
}

response = requests.get(
    "https://httpbin.org/ip",
    proxies=proxies,
    timeout=(5, 20),
)

response.raise_for_status()
print(response.json())

timeout=(5, 20) đặt giới hạn riêng cho thời gian kết nối và thời gian chờ đọc dữ liệu. Không nên gọi Requests mà thiếu timeout, vì một proxy không phản hồi có thể làm worker bị treo quá lâu.

Mã hóa username và password trong proxy URL

Nếu thông tin xác thực chứa ký tự như @, :, / hoặc #, cần URL-encode trước khi ghép thành URL:

from urllib.parse import quote

username = quote("your_username", safe="")
password = quote("your_password", safe="")

proxy_url = f"http://{username}:{password}@HOST:PORT"

Không ghi credentials thật trực tiếp vào repository. Hãy đọc từ biến môi trường hoặc secret manager, đồng thời tránh in toàn bộ proxy URL ra log.

Xoay proxy ngẫu nhiên bằng random.choice()

Với danh sách nhỏ và các request độc lập, chọn ngẫu nhiên là cách dễ triển khai:

import random
import requests

PROXY_POOL = [
    "http://HOST_1:PORT_1",
    "http://HOST_2:PORT_2",
    "http://HOST_3:PORT_3",
]


def build_proxies(proxy_url: str) -> dict[str, str]:
    return {
        "http": proxy_url,
        "https": proxy_url,
    }


def fetch(url: str) -> requests.Response:
    proxy_url = random.choice(PROXY_POOL)
    response = requests.get(
        url,
        proxies=build_proxies(proxy_url),
        timeout=(5, 20),
    )
    response.raise_for_status()
    return response


result = fetch("https://httpbin.org/ip")
print(result.json())

Random không bảo đảm phân phối đều trong một khoảng ngắn. Khi chỉ có ba proxy, cùng một endpoint có thể được chọn hai hoặc ba lần liên tiếp. Nếu cần mỗi proxy được dùng lần lượt, round-robin phù hợp hơn.

Xoay proxy theo round-robin

itertools.cycle() tạo iterator lặp vô hạn qua danh sách:

from itertools import cycle
import requests

PROXY_POOL = [
    "http://HOST_1:PORT_1",
    "http://HOST_2:PORT_2",
    "http://HOST_3:PORT_3",
]

proxy_cycle = cycle(PROXY_POOL)


def fetch_round_robin(url: str) -> requests.Response:
    proxy_url = next(proxy_cycle)
    response = requests.get(
        url,
        proxies={"http": proxy_url, "https": proxy_url},
        timeout=(5, 20),
    )
    response.raise_for_status()
    return response

Round-robin dễ dự đoán và giúp phân phối số lần gọi tương đối đều. Nhược điểm là proxy lỗi vẫn tiếp tục xuất hiện trong vòng lặp. Hệ thống thực tế cần theo dõi trạng thái và tạm loại endpoint không hoạt động.

Dùng requests.Session() để tái sử dụng kết nối

Session duy trì cookie và sử dụng connection pooling. Điều này giảm chi phí tạo kết nối mới khi nhiều request đi qua cùng proxy.

import requests

session = requests.Session()
session.headers.update({
    "Accept": "application/json",
    "User-Agent": "authorized-data-client/1.0",
})

proxy_url = "http://HOST:PORT"

response = session.get(
    "https://httpbin.org/ip",
    proxies={"http": proxy_url, "https": proxy_url},
    timeout=(5, 20),
)
response.raise_for_status()

Nếu một workflow cần giữ cookie và IP, hãy tạo một Session gắn với một proxy rồi dùng nó cho toàn bộ workflow. Không nên chia sẻ cùng Session giữa nhiều luồng mà không kiểm soát, vì Requests Session không được thiết kế như một đối tượng thread-safe hoàn toàn.

Retry đúng cách khi proxy bị lỗi

Requests không tự động retry mọi kết nối thất bại. Có thể gắn urllib3.util.Retry vào HTTPAdapter để xử lý lỗi kết nối hoặc một số status code phù hợp:

import requests
from requests.adapters import HTTPAdapter
from urllib3.util import Retry


def create_session() -> requests.Session:
    retry = Retry(
        total=2,
        connect=2,
        read=1,
        status=1,
        backoff_factor=0.5,
        status_forcelist={429, 502, 503, 504},
        allowed_methods={"GET", "HEAD", "OPTIONS"},
        respect_retry_after_header=True,
    )

    adapter = HTTPAdapter(max_retries=retry)
    session = requests.Session()
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    return session

Chỉ retry tự động những phương thức idempotent khi bạn hiểu rõ tác động. Không nên retry POST một cách mù quáng vì request có thể đã được máy chủ xử lý dù client chưa nhận được phản hồi.

Retry của adapter thường lặp lại request qua cùng cấu hình proxy. Nếu mục tiêu là đổi proxy sau khi một endpoint thất bại, cần một vòng lặp bên ngoài để chọn endpoint khác.

Mẫu proxy pool có cooldown và đổi proxy khi lỗi

Ví dụ sau quản lý danh sách proxy, dùng round-robin và tạm loại proxy lỗi trong một khoảng thời gian. Code chỉ retry các request GET độc lập:

from __future__ import annotations

from dataclasses import dataclass
from itertools import cycle
from time import monotonic, sleep

import requests


@dataclass
class ProxyState:
    url: str
    failures: int = 0
    disabled_until: float = 0.0


class ProxyPool:
    def __init__(self, proxy_urls: list[str], cooldown: int = 60):
        if not proxy_urls:
            raise ValueError("Proxy pool không được để trống")

        self.items = [ProxyState(url=url) for url in proxy_urls]
        self.iterator = cycle(self.items)
        self.cooldown = cooldown

    def next_available(self) -> ProxyState:
        now = monotonic()

        for _ in range(len(self.items)):
            item = next(self.iterator)
            if item.disabled_until <= now:
                return item

        wait_for = min(item.disabled_until for item in self.items) - now
        if wait_for > 0:
            sleep(min(wait_for, 5))

        return self.next_available()

    def mark_success(self, item: ProxyState) -> None:
        item.failures = 0
        item.disabled_until = 0.0

    def mark_failure(self, item: ProxyState) -> None:
        item.failures += 1
        item.disabled_until = monotonic() + self.cooldown


def proxy_dict(proxy_url: str) -> dict[str, str]:
    return {"http": proxy_url, "https": proxy_url}


def get_with_rotation(
    session: requests.Session,
    pool: ProxyPool,
    url: str,
    max_attempts: int = 3,
) -> requests.Response:
    last_error: Exception | None = None

    for _ in range(max_attempts):
        item = pool.next_available()

        try:
            response = session.get(
                url,
                proxies=proxy_dict(item.url),
                timeout=(5, 20),
            )

            if response.status_code in {429, 502, 503, 504}:
                raise requests.HTTPError(
                    f"Trạng thái tạm thời: {response.status_code}",
                    response=response,
                )

            response.raise_for_status()
            pool.mark_success(item)
            return response

        except (requests.Timeout, requests.ProxyError,
                requests.ConnectionError, requests.HTTPError) as error:
            pool.mark_failure(item)
            last_error = error

    raise RuntimeError("Không proxy nào hoàn tất request") from last_error


pool = ProxyPool([
    "http://HOST_1:PORT_1",
    "http://HOST_2:PORT_2",
    "http://HOST_3:PORT_3",
])

with requests.Session() as session:
    result = get_with_rotation(
        session,
        pool,
        "https://httpbin.org/ip",
    )
    print(result.json())

Đây là khung tham khảo, không phải thư viện proxy pool hoàn chỉnh. Trong production, trạng thái cần được chia sẻ an toàn giữa worker, metrics phải phân biệt lỗi proxy với lỗi website, và danh sách cần được lưu bền vững nếu tiến trình khởi động lại.

Không nên coi mọi HTTP 403 là proxy chết. 403 có thể do thiếu quyền, cookie, token, header hoặc quy tắc ứng dụng. Tự động đổi IP liên tục khi nguyên nhân nằm ở quyền truy cập chỉ làm tăng request thất bại.

Sử dụng rotating proxy gateway

Với gateway do nhà cung cấp quản lý, code chỉ kết nối vào một host và port. IP đầu ra được hệ thống phía sau lựa chọn:

import os
import requests
from urllib.parse import quote

username = quote(os.environ["PROXY_USERNAME"], safe="")
password = quote(os.environ["PROXY_PASSWORD"], safe="")
host = os.environ["PROXY_HOST"]
port = os.environ["PROXY_PORT"]

gateway = f"http://{username}:{password}@{host}:{port}"

response = requests.get(
    "https://httpbin.org/ip",
    proxies={"http": gateway, "https": gateway},
    timeout=(5, 20),
)
response.raise_for_status()
print(response.json())

Ứng dụng không cần giữ danh sách IP, nhưng phải hiểu chính sách của gateway. Một số dịch vụ đổi IP theo mỗi kết nối; số khác hỗ trợ session token để giữ IP trong khoảng thời gian. Cách truyền quốc gia hoặc session không có tiêu chuẩn chung, nên cần dùng đúng tài liệu của nhà cung cấp thay vì tự đoán cú pháp username.

Bạn có thể đọc thêm bài Rotating Proxy là gì để phân biệt IP xoay theo request và sticky session.

Kiểm tra proxy trước khi đưa vào pool

Một endpoint phản hồi ở thời điểm trước chưa chắc còn hoạt động. Health check nên dùng URL do bạn kiểm soát hoặc dịch vụ kiểm tra IP được phép, timeout ngắn và tần suất hợp lý.

import requests


def check_proxy(proxy_url: str) -> bool:
    try:
        response = requests.get(
            "https://httpbin.org/ip",
            proxies={"http": proxy_url, "https": proxy_url},
            timeout=(3, 8),
        )
        return response.ok
    except requests.RequestException:
        return False

Khi kiểm tra nhiều proxy, không nên mở hàng nghìn kết nối đồng thời. Hãy đặt giới hạn concurrency, cache kết quả và tách health check khỏi worker chính. Trước khi tích hợp vào code, bạn cũng có thể kiểm tra thủ công bằng Proxy Checker.

Chọn random, round-robin hay gateway?

Nhu cầu Lựa chọn phù hợp
Thử nghiệm nhanh với danh sách nhỏ Random
Muốn phân phối đều và dễ dự đoán Round-robin
Cần theo dõi chất lượng từng IP Client-side pool có health state
Không muốn quản lý danh sách IP Rotating gateway
Workflow nhiều bước cần giữ IP Proxy tĩnh hoặc sticky session
Nhiều worker chạy phân tán Pool trạng thái dùng chung hoặc gateway

Không có thuật toán xoay nào tự làm proxy nhanh hơn hoặc bảo đảm request thành công. Kết quả còn phụ thuộc hạ tầng, website đích, khoảng cách địa lý, timeout, giới hạn tần suất và chất lượng từng endpoint.

Dùng Residential Proxy cho Python khi nào?

Residential Proxy dùng địa chỉ IP gắn với mạng dân dụng và có thể phù hợp khi doanh nghiệp được phép kiểm tra nội dung theo khu vực hoặc thu thập dữ liệu công khai cần tín hiệu vị trí. Nó thường có chi phí và độ trễ khác datacenter proxy, nên không phải lựa chọn mặc định cho mọi script.

Với tác vụ nội bộ, API cho phép truy cập hoặc website không kiểm tra vị trí, proxy datacenter có thể đơn giản và tiết kiệm hơn. Hãy chọn loại IP theo yêu cầu thật thay vì mặc định residential luôn tốt hơn.

Nếu đang thử nghiệm cú pháp, bài proxy free là gì giải thích rủi ro của proxy công khai. Không gửi token, cookie, mật khẩu hoặc dữ liệu nhạy cảm qua endpoint miễn phí không rõ đơn vị vận hành.

Thông tin về các loại proxy và công cụ liên quan có thể xem trên Proxify.

Các lỗi thường gặp khi rotate proxies bằng Python

ProxyError hoặc không kết nối được

Kiểm tra protocol, host, port, firewall và trạng thái endpoint. Đừng đặt https:// cho proxy chỉ vì URL đích là HTTPS; protocol trong proxy URL phải phản ánh cách kết nối đến proxy.

Lỗi 407 Proxy Authentication Required

Credentials thiếu, sai hoặc chưa URL-encode. Nếu nhà cung cấp dùng IP whitelist, hãy kiểm tra IP máy chủ chạy script đã được cho phép.

Cùng một IP xuất hiện nhiều lần

Với random, đây là kết quả bình thường. Với gateway, IP có thể được giữ theo connection pooling hoặc session. Cần kiểm tra chính sách rotation và đóng/tách phiên đúng cách nếu mỗi request độc lập phải dùng IP mới.

Session bị mất giữa workflow

Nguyên nhân có thể là đổi proxy giữa các bước. Hãy gắn một Session với một proxy hoặc dùng sticky session cho toàn bộ quy trình.

Retry làm request lặp quá nhiều

Retry ở adapter cộng với vòng lặp đổi proxy có thể nhân số request. Ví dụ hai retry bên trong và ba lần đổi proxy có thể tạo nhiều hơn ba lần gọi. Hãy đặt ngân sách retry tổng và log số attempt thực tế.

Log làm lộ mật khẩu proxy

Không in nguyên proxy URL có credentials. Khi log, chỉ giữ ID nội bộ hoặc host đã che một phần. Secret cần nằm trong biến môi trường hay secret manager.

Checklist triển khai an toàn

  1. Xác định request độc lập hay cần sticky session.

  2. Luôn đặt connect timeout và read timeout.

  3. Chỉ retry phương thức và status code phù hợp.

  4. Đặt giới hạn attempt tổng để tránh vòng lặp vô hạn.

  5. Tách lỗi proxy, lỗi DNS, lỗi TLS và lỗi HTTP của website.

  6. Tạm loại proxy lỗi thay vì xóa vĩnh viễn sau một lần thất bại.

  7. Theo dõi latency, tỷ lệ thành công và thời điểm kiểm tra gần nhất.

  8. Không log credentials, cookie hoặc token.

  9. Giới hạn concurrency và tôn trọng rate limit.

  10. Chỉ truy cập dữ liệu và hệ thống trong phạm vi được phép.

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

Làm sao xoay proxy sau mỗi request trong Python?

Chọn một proxy mới trước mỗi lần gọi requests.get() bằng random, round-robin hoặc dùng rotating gateway đổi IP phía máy chủ. Với gateway, cần xem chính sách của nhà cung cấp để biết IP đổi theo request hay kết nối.

Requests có tự xoay proxy không?

Không. Requests chỉ sử dụng dictionary proxies được truyền vào. Logic chọn endpoint, health check và đổi proxy phải do ứng dụng hoặc nhà cung cấp thực hiện.

Có nên dùng random.choice() không?

Phù hợp với thử nghiệm và danh sách nhỏ, nhưng không bảo đảm phân phối đều hoặc tránh proxy lỗi. Production nên có trạng thái health, cooldown và giới hạn retry.

Retry có tự chọn proxy mới không?

Retry trong HTTPAdapter thường gửi lại bằng cùng cấu hình proxy. Muốn đổi endpoint, cần vòng lặp bên ngoài chọn proxy khác sau khi bắt lỗi.

Xoay proxy có làm mất cookie không?

Đổi proxy không tự xóa cookie trong Requests Session, nhưng IP thay đổi giữa phiên có thể khiến website đánh giá phiên không nhất quán. Workflow nhiều bước nên giữ proxy ổn định.

SOCKS5 dùng với Requests thế nào?

Cài requests[socks], sau đó dùng URL socks5:// hoặc socks5h://. Biến thể socks5h chuyển việc phân giải hostname qua proxy.

Kết luận

Cách xoay proxy trong Python có thể bắt đầu bằng random.choice() hoặc itertools.cycle(), nhưng hệ thống ổn định cần nhiều hơn việc đổi một URL trong dictionary. Timeout, Session, retry có giới hạn, health state, cooldown và phân loại lỗi mới là các thành phần quyết định độ tin cậy.

Nếu request độc lập và bạn muốn kiểm soát từng endpoint, client-side proxy pool là lựa chọn linh hoạt. Nếu muốn giảm phần quản lý danh sách, rotating gateway đơn giản hơn. Với workflow nhiều bước, hãy ưu tiên proxy tĩnh hoặc sticky session. Dù chọn mô hình nào, cần giới hạn tần suất và chỉ thu thập dữ liệu trong phạm vi được phép.

© 2026 Proxify.vn. All rights reserved.

Bảo mật · An toàn · Tự động