Python搭建代理IP池实现接口设置与整体调度

目录

前言

在网络爬虫中，代理IP池是一个非常重要的组件。由于许多网站对单个IP的请求有限制，如果我们一直使用同一个IP去请求数据，我们很快就会被封禁。因此，我们需要一个代理IP池，以便我们可以轮流使用多个代理IP，以避免被封禁的风险。

在本文中，我们将使用Python来构建一个代理IP池。我们将使用requests和BeautifulSoup库来从互联网上抓取免费代理IP，并将它们存储到一个代理IP池中。然后，我们将使用这个代理IP池来访问我们需要的数据。

本文内容涵盖以下几个方面：

1. 搭建免费代理IP爬虫
2. 将获取到的代理IP存储到数据库中
3. 构建一个代理IP池
4. 实现调度器来调度代理IP池
5. 实现带有代理IP池的爬虫

本文将涉及到一些网络编程的知识，如果您还不熟悉这些知识，请先补充相关的知识。同时，本文代码也是在Python 3.8环境中运行的。

1. 搭建免费代理IP爬虫

我们需要从互联网上抓取免费代理IP，这里我们使用的是站大爷代理ip网站上的免费代理IP。我们将使用requests和BeautifulSoup来实现爬虫。

爬虫代码如下所示：

import requests
from bs4 import BeautifulSoup

def get_proxy_ips():
    """
    Get the proxy IPs from zdaye.com
    """
    url = 'https://www.zdaye.com/'
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
    html = requests.get(url, headers=headers).text
    soup = BeautifulSoup(html, 'html.parser')
    ips = soup.find_all('tr')
    proxy_ips = []
    for ip in ips[1:]:
        lst = ip.text.strip().split('\n')
        proxy_ip = {'ip': lst[0], 'port': lst[1]}
        proxy_ips.append(proxy_ip)
    return proxy_ips

2. 将获取到的代理IP存储到数据库中

我们需要将获取到的代理IP存储到数据库中，以便我们在后续的处理中使用。在这里，我们使用MongoDB作为我们的数据库，它是一个非常流行的文档型数据库，特别适合存储非结构化数据。

我们需要安装pymongo库来连接MongoDB。安装命令如下：

pip install pymongo

接下来，我们需要定义一个函数来将代理IP存储到MongoDB中。代码如下所示：

from pymongo import MongoClient

def save_proxy_ips(proxy_ips):
    """
    Save the proxy IPs to MongoDB
    """
    client = MongoClient('mongodb://localhost:27017/')
    db = client['proxy_ips']
    coll = db['ips']
    coll.delete_many({})
    coll.insert_many(proxy_ips)

上面的代码将获取到的代理IP列表作为参数传递，然后将代理IP列表存储到名为“proxy_ips”的数据库中的“ips”集合中。

3. 构建一个代理IP池

现在我们已经有了一个爬虫和一个数据库，接下来我们将构建一个代理IP池。在这个代理IP池中，我们将从数据库中随机选择一个代理IP，并使用它来访问我们需要的数据。如果代理IP无法使用，则需要从池中删除该代理IP。如果池中的代理IP数量太少，则需要重新从互联网上抓取免费代理IP，并将其存储到数据库中。

实现代码如下所示：

import random

class ProxyPool:
    def __init__(self, threshold=5):
        """
        Initialize the proxy pool
        """
        self.threshold = threshold
        self.client = MongoClient('mongodb://localhost:27017/')
        self.db = self.client['proxy_ips']
        self.coll = self.db['ips']

    def get_proxy_ip(self):
        """
        Get a random proxy IP from the pool
        """
        count = self.coll.count_documents({})
        if count == 0:
            return None

        proxy_ips = self.coll.find({}, {'_id': 0})
        ips = [proxy_ip for proxy_ip in proxy_ips]
        proxy_ip = random.choice(ips)
        ip = 'http://' + proxy_ip['ip'] + ':' + proxy_ip['port']

        return {'http': ip}

    def delete_proxy_ip(self, proxy_ip):
        """
        Delete the proxy IP from the pool
        """
        self.coll.delete_one(proxy_ip)

    def check_proxy_ip(self, proxy_ip):
        """
        Check if the given proxy IP is available
        """
        proxies = {'http': 'http://' + proxy_ip['ip'] + ':' + proxy_ip['port']}
        try:
            requests.get('https://www.baidu.com/', proxies=proxies, timeout=5)
            return True
        except:
            return False

    def update_pool(self):
        """
        Update the proxy pool
        """
        count = self.coll.count_documents({})
        if count < self.threshold:
            proxy_ips = get_proxy_ips()
            save_proxy_ips(proxy_ips)

上面的代码中，我们定义了一个名为ProxyPool的类。这个类有四个方法：

• get_proxy_ip：从代理IP池中获取一个随机代理IP。
• delete_proxy_ip：从代理IP池中删除一个代理IP。
• check_proxy_ip：检查给定的代理IP是否可用。
• update_pool：检查池中的代理IP数量是否低于阈值，如果低于阈值，则从互联网上获取新的代理IP列表，并将其存储到数据库中。

值得注意的是，我们使用了MongoDB作为代理IP池的存储介质。因此，我们需要安装MongoDB数据库，并确保它在运行。

4. 实现调度器来调度代理IP池

为了使用代理IP池，我们需要实现一个调度器来调度代理IP池。调度器需要获取一个随机的代理IP，并将其传递给请求。如果请求返回状态码为403（表示无权访问），则需要从代理IP池中删除该代理IP，并重新获取一个代理IP。

实现代码如下所示：

class Scheduler:
    def __init__(self):
        self.proxy_pool = ProxyPool()

    def request(self, url):
        """
        Send a request to the given url using a random proxy IP
        """
        while True:
            proxy_ip = self.proxy_pool.get_proxy_ip()
            if proxy_ip is None:
                return None
            try:
                response = requests.get(url, proxies=proxy_ip, timeout=5)
                if response.status_code == 200:
                    return response
                elif response.status_code == 403:
                    self.proxy_pool.delete_proxy_ip(proxy_ip)
                else:
                    continue
            except:
                self.proxy_pool.delete_proxy_ip(proxy_ip)

    def run(self):
        """
        Run the scheduler to update the proxy pool
        """
        self.proxy_pool.update_pool()

上面的代码中，我们定义了一个名为Scheduler的类。这个类有两个方法：

• request：使用随机代理IP发送请求。
• run：运行调度器来更新代理IP池。

当我们向调度器发出请求时，调度器将从代理IP池中获取一个随机代理IP，并将其作为请求的代理IP。如果请求返回状态码为200，则说明代理IP可用，可以将响应返回给调用者。如果状态码为403，则需要从代理IP池中删除该代理IP，并重新获取一个代理IP。如果请求发生异常，则也需要从代理IP池中删除该代理IP。

5. 实现带有代理IP池的爬虫

现在我们已经有了一个代理IP池和一个调度器，接下来我们将实现一个带有代理IP池的爬虫。在这个爬虫中，我们将使用调度器来调度代理IP池，并将获取到的数据存储到MongoDB数据库中。

实现代码如下所示：

import time

class Spider:
    def __init__(self):
        self.scheduler = Scheduler()
        self.client = MongoClient('mongodb://localhost:27017/')
        self.db = self.client['data']
        self.coll = self.db['info']

    def crawl(self):
        """
        Crawl data using the proxy pool
        """
        while True:
            response = self.scheduler.request('https://www.example.com/')
            if response is not None:
                html = response.text
                # parse the html to get the data
                data = {}
                self.coll.insert_one(data)
            time.sleep(1)

    def run(self):
        """
        Run the spider to crawl data
        """
        while True:
            self.scheduler.run()
            self.crawl()
            time.sleep(10)

上面的代码中，我们定义了一个名为Spider的类。这个类有两个方法：

• crawl：使用代理IP池来爬取数据，并将数据存储到MongoDB数据库中。
• run：运行爬虫来爬取数据。

当我们运行爬虫时，它将首先运行调度器来更新代理IP池。然后，它将使用代理IP池来爬取数据，并将数据存储到MongoDB数据库中。最后，它将休眠10秒钟，然后重复这个过程。

总结

在本文中，我们使用Python来构建了一个代理IP池。我们首先使用requests和BeautifulSoup库来从互联网上抓取免费代理IP，并将其存储到MongoDB数据库中。然后，我们构建了一个代理IP池，从中随机选择代理IP，并使用它来访问我们需要的数据。如果代理IP无法使用，则从池中删除该代理IP。如果池中的代理IP数量太少，则重新从互联网上获取新的代理IP列表。

最后，我们实现了一个带有代理IP池的爬虫，使用调度器来调度代理IP池。该爬虫将获取数据，并将数据存储到MongoDB数据库中。