代理IP的 3 层用法,从手动换IP到高并发采集(附完整代码)

0 阅读5分钟

代理IP的 3 层用法,从手动换IP到高并发采集(附完整代码)

同一个爬虫,加了代理池和并发后,采集速度从 200 条/分钟提到 1200 条/分钟,还不用半夜起来处理封禁。本文把代理IP从"能接入"到"高并发"的 3 个层级一次讲完,代码基于真实服务商接口写成,换成你自己的接入信息即可运行。

层级做法典型采集速度封禁率
第 1 层单代理接入~200 条/分钟较高
第 2 层代理池轮换~600 条/分钟中
第 3 层代理 × 并发~1200 条/分钟中

第 1 层:接入——单代理配置

现在主流的短效动态IP都支持白名单和账号密码两种鉴权:

import requests

# 方式A:白名单鉴权(提取时 auto_whitelist=true 自动加白,或会员中心手动加白)
proxies = {
    "http": "http://113.xxx.xxx.xxx:4231",     # 提取到的 IP:端口
    "https": "http://113.xxx.xxx.xxx:4231",
}

# 方式B:账号密码鉴权(多机部署不用挨个加白)
# proxies = {
#     "http": "http://你的账号:你的密码@113.xxx.xxx.xxx:4231",
#     "https": "http://你的账号:你的密码@113.xxx.xxx.xxx:4231",
# }

resp = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=10)
print(resp.json())  # origin 是代理IP,说明生效了

三个必踩的坑:

  1. proxies 键必须小写 http / https——写成大写会静默失效,不报错但你一直在裸奔,这是新手问得最多的问题。
  2. timeout 必须设,否则一个坏IP能卡死整个任务。
  3. SOCKS5 先 pip install "requests[socks]",地址写 socks5h://(带 h 把域名解析放到代理出口,防 DNS 泄露,强风控场景必用)。

第 2 层:轮换——代理池入门

单IP扛不住高并发,就养一个池子:通过服务商 API 批量提取、随机取用、失效自动剔除。

import time
import random
import requests
from collections import deque

API_BASE = "https://api.sdbufeng.vip"

def get_token(username, password):
    """会员账号登录换 API Token(缓存起来,别每次提取都重新登录)"""
    resp = requests.get(f"{API_BASE}/api/login",
        params={"username": username, "password": password}, timeout=10).json()
    if resp.get("status") == 0:
        return resp["data"]["token"]
    raise Exception(f"登录失败: {resp.get('msg')}")

class SimpleProxyPool:
    """最小可用代理池:提取 → 校验 → 轮换 → 剔除失效"""

    def __init__(self, token, proxy_type="http"):
        self.token = token
        self.proxy_type = proxy_type      # http 或 socks5
        self.pool = deque(maxlen=200)
        self.failed = set()               # 失效IP黑名单

    def fetch_proxies(self, amount=20):
        resp = requests.get(f"{API_BASE}/bf/shared/getip", params={
            "token": self.token,
            "proxy_type": self.proxy_type,
            "amount": amount,
            "expire": "5-30",             # 有效期档位,按套餐和任务周期填
            "format": "txt",              # 每行一个 ip:端口
            "auto_whitelist": "true",     # 自动加白本机出口IP
        }, timeout=10)
        for line in resp.text.strip().splitlines():
            ip_port = line.strip()
            if ip_port and ip_port not in self.failed:
                self.pool.append(ip_port)
        print(f"[池] 当前存量: {len(self.pool)}")

    def check(self, proxy):
        try:
            requests.get("https://httpbin.org/ip",
                proxies={"http": f"http://{proxy}", "https": f"http://{proxy}"},
                timeout=5)
            return True
        except Exception:
            return False

    def get(self):
        for _ in range(5):
            if self.pool:
                proxy = random.choice(list(self.pool))
                if self.check(proxy):
                    return proxy
                self.pool.remove(proxy)
                self.failed.add(proxy)
            else:
                self.fetch_proxies()
        raise RuntimeError("代理池已枯竭,请检查提取频率或IP质量")

    def report_fail(self, proxy):
        """业务请求失败时调用,把坏IP踢出池子"""
        if proxy in self.pool:
            self.pool.remove(proxy)
            self.failed.add(proxy)


# ---- 使用示例 ----
token = get_token("你的账号", "你的密码")   # 建议放环境变量
pool = SimpleProxyPool(token=token)

for i in range(10):
    proxy = pool.get()
    try:
        requests.get("https://目标网站.com/data",
            proxies={"http": f"http://{proxy}", "https": f"http://{proxy}"},
            timeout=10)
        print(f"[{i}] {proxy} 采集成功")
    except Exception:
        pool.report_fail(proxy)
    time.sleep(random.uniform(0.5, 1.5))   # 随机延迟,别用固定间隔

三个决定池子能不能跑生产的细节:

  1. 失败IP必须拉黑:report_fail 别省,坏IP反复复用是封禁率居高不下的头号原因。
  2. 延迟要随机:固定 sleep(1) 是典型机器特征,用 random.uniform 打散。
  3. 池子大小 ≈ 并发数 × 10:短效IP一般有 3/5/10/30 分钟多档有效期,expire 要和任务周期对齐——任务跑 20 分钟别选 3 分钟档,中途换IP会断会话。

第 3 层:并发——代理 × 异步

到几百条/分钟还想再快,上 asyncio + aiohttp(比 threading 更适合采集这种 IO 密集任务):

import asyncio
import aiohttp

PROXY = "http://113.xxx.xxx.xxx:4231"   # 从池子里取出的 IP:端口
TARGETS = [f"https://目标网站.com/item/{i}" for i in range(1000)]

async def fetch(session, url, sem):
    async with sem:                     # 信号量控制并发
        try:
            async with session.get(url, proxy=PROXY,
                    timeout=aiohttp.ClientTimeout(total=15)) as resp:
                await resp.text()
                return True
        except Exception:
            return False

async def main():
    sem = asyncio.Semaphore(50)         # 并发数,先从 50 起步
    async with aiohttp.ClientSession(
            connector=aiohttp.TCPConnector(limit=100)) as session:
        results = await asyncio.gather(
            *[fetch(session, url, sem) for url in TARGETS])
    print(f"成功 {sum(results)}/{len(TARGETS)}")

asyncio.run(main())

并发数不是越大越好,经验公式:

并发数 ≈ 代理IP数 × 单IP安全QPS(1~2) × 目标站容忍度系数(0.5~1)

例:50 个可用IP、单IP安全 QPS 1.5、系数 0.8 → 并发 ≈ 60。超了封禁率陡增,"快"就变成"返工"。生产上更稳的写法:并发层和第 2 层池子组合——每个请求从池里取IP,失败调 report_fail,池子自动补货。


顺带说一句:动态还是静态?

业务选什么
数据采集、批量抓取、临时任务短效动态IP(本文用的就是它)
电商多店铺、社媒账号、要长期保持登录态静态独享IP——动态IP频繁跳变本身就是风控信号

总结

  1. 接入解决"从 0 到 1":键要小写、必设超时、SOCKS5 用 socks5h://
  2. 轮换解决"IP不够用":失败拉黑、随机延迟、有效期和任务周期对齐
  3. 并发解决"速度不够":并发数按公式算,池子+并发组合才是生产形态