Selenium浏览器IP轮换方案咨询：Python定时访问需每次更换IP

嘿，针对你每30秒换IP访问网站的需求，我整理了几个从高效到备选的方案，还有你问到的具体实现细节：

免费、无需额外付费，而且IP更换逻辑成熟稳定，完全满足你每30秒换IP的需求。下面是Ubuntu服务器上的完整配置步骤：

1. 安装Tor、Firefox和依赖 #

登录你的EC2 Ubuntu实例，执行以下命令：

# 更新系统包
sudo apt update && sudo apt upgrade -y
# 安装Tor和控制工具
sudo apt install tor -y
# 安装Firefox和geckodriver（Selenium需要）
sudo apt install firefox firefox-geckodriver -y
# 安装Python依赖
sudo apt install python3-pip -y
pip3 install selenium stem requests

2. 配置Tor允许远程控制 #

编辑Tor的配置文件：

sudo nano /etc/tor/torrc

找到并修改以下配置（没有的话就添加）：

ControlPort 9051
CookieAuthentication 1

保存后重启Tor服务：

sudo systemctl restart tor

注意：因为是本地进程控制Tor，所以不需要在EC2安全组开放9051端口，仅本地访问即可。

3. Python脚本实现自动换IP + Selenium访问 #

这个脚本会每次访问前通过Tor控制端口更换IP，然后用Selenium加载目标网站：

from selenium import webdriver
from selenium.webdriver.firefox.options import Options
from stem import Signal
from stem.control import Controller
import requests
import time

# 配置Tor代理的Firefox选项（无头模式适配EC2无桌面环境）
def setup_firefox_with_tor():
    options = Options()
    options.add_argument('--headless')  # 无头模式，适合服务器环境
    options.add_argument('--proxy-server=socks5://127.0.0.1:9050')
    # 禁用WebRTC防止IP泄漏
    options.set_preference("media.peerconnection.enabled", False)
    driver = webdriver.Firefox(options=options)
    return driver

# 更换Tor IP的函数
def renew_tor_ip():
    with Controller.from_port(port=9051) as controller:
        controller.authenticate()  # 使用Cookie认证，无需手动设置密码
        controller.signal(Signal.NEWNYM)
        time.sleep(5)  # 给Tor预留切换节点的时间

# 主逻辑
if __name__ == "__main__":
    target_url = "你的目标网站URL"
    while True:
        renew_tor_ip()
        driver = setup_firefox_with_tor()
        try:
            driver.get(target_url)
            # 验证当前Tor出口IP
            ip_resp = requests.get(
                "http://httpbin.org/ip",
                proxies={"http": "socks5://127.0.0.1:9050", "https": "socks5://127.0.0.1:9050"},
                timeout=10
            )
            print(f"成功访问，当前出口IP: {ip_resp.json()['origin']}")
            # 这里可以添加你的业务逻辑，比如页面数据提取、表单提交等
        except Exception as e:
            print(f"访问出错: {str(e)}")
        finally:
            driver.quit()
        time.sleep(30)  # 等待30秒后再次执行访问

如果不想用Tor，也可以自己搭建一个简单的免费代理池，从多个免费代理源抓取并验证可用IP。下面是一个基础的Python脚本示例：

import requests
from bs4 import BeautifulSoup
import threading
from queue import Queue
import time

# 代理验证函数，验证通过的代理放入队列
def check_proxy(proxy, queue):
    try:
        response = requests.get(
            "http://httpbin.org/ip",
            proxies={"http": proxy, "https": proxy},
            timeout=5,
            headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36"}
        )
        if response.status_code == 200:
            queue.put(proxy)
            print(f"发现可用代理: {proxy}")
    except Exception:
        pass

# 从多源抓取免费代理
def get_free_proxies():
    proxies = set()
    headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36"}

    # 源1：国内免费代理站
    try:
        resp = requests.get("https://www.xicidaili.com/nn/", headers=headers)
        soup = BeautifulSoup(resp.text, "html.parser")
        for row in soup.find_all("tr")[1:10]:  # 取前10条代理
            cols = row.find_all("td")
            proxy = f"{cols[1].text}:{cols[2].text}"
            proxies.add(proxy)
    except Exception:
        pass

    # 源2：另一个免费代理站
    try:
        resp = requests.get("https://www.kuaidaili.com/free/inha/", headers=headers)
        soup = BeautifulSoup(resp.text, "html.parser")
        for row in soup.find_all("tr")[1:10]:
            cols = row.find_all("td")
            proxy = f"{cols[0].text}:{cols[1].text}"
            proxies.add(proxy)
    except Exception:
        pass

    # 多线程验证代理可用性
    queue = Queue()
    threads = []
    for proxy in proxies:
        t = threading.Thread(target=check_proxy, args=(proxy, queue))
        t.start()
        threads.append(t)
    for t in threads:
        t.join()

    # 收集所有可用代理
    valid_proxies = []
    while not queue.empty():
        valid_proxies.append(queue.get())
    return valid_proxies

# 主使用逻辑
if __name__ == "__main__":
    target_url = "你的目标网站URL"
    while True:
        valid_proxies = get_free_proxies()
        if valid_proxies:
            for proxy in valid_proxies:
                try:
                    resp = requests.get(
                        target_url,
                        proxies={"http": proxy, "https": proxy},
                        timeout=10,
                        headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36"}
                    )
                    print(f"用代理{proxy}访问成功，状态码: {resp.status_code}")
                    # 添加你的业务逻辑
                    break
                except Exception:
                    print(f"代理{proxy}不可用，跳过")
                    continue
        time.sleep(30)

缺点：免费代理稳定性极差，大部分会在几分钟内失效，适合临时测试，长期使用不推荐。

• 付费代理服务：如果预算允许，这是最省心的方案。选择支持API批量获取代理的服务商，脚本直接调用API获取可用IP（比如住宅代理，IP更贴近真实用户，不容易被网站封禁），无需自己维护代理池或Tor配置。
• AWS EC2弹性IP：成本极高，且AWS对弹性IP的创建/释放有配额限制，每30秒换IP的操作很容易触发限制，完全不推荐。

内容的提问来源于stack exchange，提问作者Timothé