爬虫必备——ProxyPool代理池

这几年流行微服务，好处很多，比如解耦：各个功能原子化，互不干扰；比如开发更规范：自己管自己的项目，出了问题容易找到责任方。这里给大家分享一个代理池的服务，用的是收费的蘑菇代理，比较过全网的代理IP这家还算良心。

首先我确定了几个功能：

1. 随时获取代理IP;
2. 为了应对并发和网速等实际问题，我需要获取独占IP，不和其他客户端共享这些IP；
3. 更新代理池；
4. 修改代理池中IP数量；
5. 开启/关闭自动更新。

我用了flask作为webserver，本文只讲逻辑，没用nginx、gun等部署方案。代码在https://github.com/zmy537565154/ProxyPool

config

配置文件是一些默认值和日志对象的声明。其中自动更新的值可以在项目启动后通过http请求来修改。

import logging
import sys
import time
import os
import redis


# 默认代理数量
ip_count = 1

# 蘑菇代理appKey
app_key = 'fb7d0ef415*******e347323930f928d'

# 端口
port = 10008

# 自动更新
auto_update_flag = False

# 日志管理
logger = logging.getLogger('logger')
formatter = logging.Formatter('%(asctime)s %(levelname)-8s: %(message)s \n')
try:
    file_handler = logging.FileHandler(
        'logs/{}.log'.format(time.strftime('%Y-%m-%d_%H:%M:%S', time.localtime(time.time()))))
except:
    os.mkdir('logs')
    file_handler = logging.FileHandler(
        'logs/{}.log'.format(time.strftime('%Y-%m-%d_%H:%M:%S', time.localtime(time.time()))))
file_handler.setFormatter(formatter)
console_handler = logging.StreamHandler(sys.stdout)
console_handler.formatter = formatter

logger.addHandler(file_handler)
logger.addHandler(console_handler)
logger.setLevel(logging.INFO)

# redis
redis_config = {
    'host': '192.168.10.***',
    'port': 6379,
    'db':15,
}
pool = redis.ConnectionPool(**redis_config)
redis_handler = redis.Redis(connection_pool=pool)

proxy_class

这里实现了一个单例类，为的是所有客户端共享一个对象。代理保存在redis中。

import threading
from config import ip_count, app_key, logger, redis_handler, auto_update_flag
import json
import requests
import time


class Proxy(object):
    INSTANCE = None
    lock = threading.RLock()

    def __init__(self):
        self.ip_count = ip_count
        self.proxies = {}
        self.auto_update_flag = auto_update_flag

    def __new__(cls):
        cls.lock.acquire()
        if cls.INSTANCE is None:
            cls.INSTANCE = super(Proxy, cls).__new__(cls)
        cls.lock.release()
        return cls.INSTANCE

    # 修改默认获取IP数量
    def modify_ip_count(self, num):
        self.ip_count = num

    # 解决特殊需求，单独返回若干个代理,share=False时不和其他客户端共享，独占几个代理，share=True时将代理放入redis
    def get_proxy(self, count, share=False):
        url = 'http://piping.mogumiao.com/proxy/api/get_ip_al?appKey={}&count={}&expiryDate=0&format=1&newLine=2'.format(
            app_key, count)
        try:
            resp = requests.get(url)
        except:
            logger.warning('调用第三方接口失败,状态码:' + str(resp.status_code))
            return {'isSuccess': False, 'code': 109, 'msg': '调用第三方接口失败'}
        resp = json.loads(resp.text)
        if resp['code'] != '0':
            logger.warning('请求代理IP失败,响应结果:' + str(resp))
            return {'isSuccess': False, 'code': 101, 'msg': resp['msg']}
        else:
            proxy_list = []
            for r in resp['msg']:
                ip = r['ip']
                port = r['port']
                proxy_list.append(ip + ':' + port)
                if share:
                    redis_handler.sadd('proxyPool:proxyPool', ip + ':' + port)
            logger.info('请求代理IP成功,响应代理:' + str(proxy_list))
            return {'isSuccess': True, 'code': 100, 'msg': proxy_list}

    # 更新代理池，添加代理数量为默认的或用户设置的
    def update_pool(self):
        url = 'http://piping.mogumiao.com/proxy/api/get_ip_al?appKey={}&count={}&expiryDate=0&format=1&newLine=2'.format(
            app_key, self.ip_count)
        try:
            resp = requests.get(url)
        except:
            logger.warning('调用第三方接口失败,状态码:' + str(resp.status_code))
            return {'isSuccess': False, 'code': 109, 'msg': '调用第三方接口失败'}
        resp = json.loads(resp.text)
        if resp['code'] != '0':
            logger.warning('请求代理IP失败,响应结果:' + str(resp))
            return {'isSuccess': False, 'code': 101, 'msg': resp['msg']}
        else:
            proxy_list = []
            for r in resp['msg']:
                ip = r['ip']
                port = r['port']
                proxy_list.append(ip + ':' + port)
                redis_handler.sadd('proxyPool:proxyPool', ip + ':' + port)
            logger.info('请求代理IP成功,响应代理:' + str(proxy_list))
            return {
                'isSuccess': True,
                'code': 100,
                'msg': proxy_list
            }

    # 自动更新，每次检查pool中proxy数量是否足够，不够则补全
    def auto_update(self):
        while True:
            if self.auto_update_flag:
                proxies_num = len(redis_handler.smembers('proxyPool:proxyPool'))
                if proxies_num < self.ip_count:
                    self.get_proxy(self.ip_count - proxies_num, share=True)
                time.sleep(2)
            else:
                break


if __name__ == '__main__':
    a = Proxy()

app

view层

from flask import Flask, request
from config import port, logger, auto_update_flag
import requests
import json
import asyncio
import threading

from proxy_class import Proxy

app = Flask(__name__)
proxy_obj = Proxy()
if auto_update_flag:
    threading.Thread(target=proxy_obj.auto_update).start()


@app.route('/get_proxy', methods=['GET'])
def get_proxy():
    addr = request.remote_addr
    ip_count = request.args.get('count')
    logger.info(addr + ' >>> ' + '请求代理数量：' + ip_count)
    resp = proxy_obj.get_proxy(ip_count)

    return json.dumps(resp, ensure_ascii=False)


@app.route('/modify_proxy_count')
def modify_ip_count():
    ip = request.remote_addr
    proxy_obj.ip_count = request.args.get('count')
    logger.info(ip + ' >>> ' + '修改IP数量:' + proxy_obj.ip_count)
    resp = {
        'isSuccess': True,
        'code': 100,
        'msg': '修改成功'
    }
    return json.dumps(resp, ensure_ascii=False)


@app.route('/update_pool')
def update_pool():
    ip = request.remote_addr

    logger.info(ip + ' >>> ' + '更新代理池')
    resp = proxy_obj.update_pool()

    return json.dumps(resp, ensure_ascii=False)


@app.route('/auto_update')
def auto_update():
    ip = request.remote_addr
    if proxy_obj.auto_update_flag:
        logger.info(ip + ' >>> ' + '关闭自动更新')
        proxy_obj.auto_update_flag = False
        resp = {
            'isSuccess': True,
            'code': 100,
            'msg': '已关闭自动更新'
        }
        return json.dumps(resp, ensure_ascii=False)
    else:
        logger.info(ip + ' >>> ' + '开启实时更新')
        proxy_obj.auto_update_flag = True
        threading.Thread(target=proxy_obj.auto_update).start()
        resp = {
            'isSuccess': True,
            'code': 100,
            'msg': '已开启自动更新'
        }
        return json.dumps(resp, ensure_ascii=False)


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=port, debug=True)
    logger.info('服务开启')

最后最后，不同团队不同人的需求都是不同的，很多企业需要并发请求代理，这样的话flask的webserver就不好用了，需要用高并发的方案。我这里的代理池设置是全局的，没根据不同客户端进行区别对待，未来可以扩展实现权限配置的功能。