关于爬虫:5分钟自己做一个隧道代理

什么是隧道代理？咱们来看上面这张截图：

所谓隧道代理，就是一个能帮你主动更换代理 IP 的代理服务。在你的代码外面，你只须要把一个入口代理地址写死，而后失常发动申请，而指标服务器接管到的申请，每一次都是不同的代理地址。

在某代理网站上，隧道代理 50 并发每秒的价格是 4000 元 / 月：

而惯例的，先申请接口拿到一批代理 IP，再选一个发动申请的原始代理服务器，一个月价格才 600 多元：

所以，如果咱们能本人做一个隧道代理，将会省下很多钱！

隧道代理的原理，跟惯例代理的不同之处，用上面这两张图就能说分明：

要本人开发一个这样的隧道代理，咱们须要做两步：

1. 构建一个代理池
2. 实现代理主动转发

构建代理池

假如你从代理供应商手上买到的便宜代理地址为：http://xxx.com/ips，间接在浏览器下面申请，页面成果如下图所示：

当初，你须要做的就是写一个程序，周期性拜访这个 url，拉取以后最新可用的 IP 地址，而后把它放到 Redis 中。

这里，咱们应用 Redis 的 Hash 这个数据结构，其中 Hash 的字段名就是IP: 端口，外面的值就是跟每个 IP 相干的一些信息。

你这个程序须要确保，以后在 Redis 外面的代理地址，全部都是可用的。这里，我给出了一个示例程序：

"""
ProxyManager.py
~~~~~~~~~~~~~~~~~~~~~
繁难代理池管理工具，间接从 URL 中读取所有
最新的代理，并写入 Redis。"""
import yaml
import time
import json
import redis
import datetime
import requests


class ProxyManager:
    def __init__(self):
        self.config = self.read_config()
        self.redis_config = self.config['redis']
        self.client = redis.Redis(host=self.redis_config['host'],
                                  password=self.redis_config['password'],
                                  port=self.redis_config['port'])
        self.instance_dict = {}

    def read_config(self):
        with open('config.yaml') as f:
            config = yaml.safe_load(f.read())
            return config

    def read_ip(self):
        resp = requests.get(self.config['proxy']).text
        if '{' in resp:
            return []
        proxy_list = resp.split()
        return proxy_list

    def delete_ip(self, live_ips, pool_ips):
        ip_to_removed = set(pool_ips) - set(live_ips)
        if ip_to_removed:
            print('ip to be removed:', ip_to_removed)
            self.client.hdel(self.redis_config['key'], *list(ip_to_removed))

    def add_new_ips(self, live_ips, pool_ips):
        ip_to_add = set(live_ips) - set(pool_ips)
        if ip_to_add:
            print('ip to add:', ip_to_add)
            ips = {}
            for ip in ip_to_add:
                ips[ip] = json.dumps({'private_ip': ip,
                                      'ts': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')})
            self.client.hset(self.redis_config['key'], mapping=ips)

    def run(self):
        while True:
            live_ips = self.read_ip()
            pool_ips = [x.decode() for x in self.client.hgetall(self.redis_config['key'])]
            self.delete_ip(live_ips, pool_ips)
            self.add_new_ips(live_ips, pool_ips)
            time.sleep(40)


if __name__ == '__main__':
    manager = ProxyManager()
    manager.run()

其中，我把 Redis 相干的配置、代理供应商的 URL 写到了一个 yaml 配置文件中，避免被你们看到。配置文件的格局如下图所示：

因为我这个代理供应商提供的 IP，有效期是 1 - 5 分钟，所以保险起见，我每 40 秒更换一次 IP。更换的时候，采纳了增量更换的形式。把以后拉取的 IP 和 Redis 外面的已有 IP 进行比照。不在这次拉取的 IP 全副从 Redis 移除，而后把新增的 IP 加到 Redis 中。

大家在理论过程中，还能够加一些代理校验的逻辑，确保从 URL 拉下来的代理也进行有效性查看，发现有效的立即移除。

实现主动转发

要实现主动转发，咱们能够应用 OpenResty。这是一个基于 Nginx 和 Lua 实现的高性能 Web 平台。通过它，咱们能够应用 Lua 语言实现一些逻辑，例如从 Redis 读取数据，把起源申请转发到上游代理服务器……

因而，咱们应用 OpenResty 搭建一个转发服务。并把这个转发服务所在服务器的 IP 地址作为咱们的入口 IP 地址。在应用 Requests 等等网络申请客户端发送申请的时候，只须要把这个入口 IP 地址设置为代理。那么，当客户端发送申请的时候，申请首先到了 OpenResty。而后它从 Redis 中随机选一个代理 IP 来作为上游代理，并把刚刚发来的申请转发到上游代理。从而实现隧道代理的成果。

Lua 是一门十分老的语言，它的语法不少中央跟 Python 不太一样。不过你不必放心，这个配置文件我曾经写好了。大家拿过去改一改就能用。

对应的配置文件如下图所示：

worker_processes  16;        #nginx worker 数量
error_log /usr/local/openresty/nginx/logs/error.log;   #指定谬误日志文件门路
events {worker_connections 1024;}


stream {
    ## TCP 代理日志格局定义
    log_format tcp_proxy '$remote_addr [$time_local]'
                         '$protocol $status $bytes_sent $bytes_received'
                         '$session_time"$upstream_addr"''"$upstream_bytes_sent""$upstream_bytes_received" "$upstream_connect_time"';
    ## TCP 代理日志配置
    access_log /usr/local/openresty/nginx/logs/access.log tcp_proxy;
    open_log_file_cache off;

    ## TCP 代理配置
    upstream backend{
        server 127.0.0.2:1101;# 爱写啥写啥  反正上面的代码也给你改了
        balancer_by_lua_block {
            -- 初始化 balancer
            local balancer = require "ngx.balancer"
            local host = ""
            local port = 0
            host = ngx.ctx.proxy_host
            port = ngx.ctx.proxy_port
            -- 设置 balancer
            local ok, err = balancer.set_current_peer(host, port)
            if not ok then
                ngx.log(ngx.ERR, "failed to set the peer:", err)
            end
        }
    }


    server {
        preread_by_lua_block{local redis = require("resty.redis")
            -- 创立实例
            local redis_instance = redis:new()
            -- 设置超时（毫秒）redis_instance:set_timeout(3000)
            -- 建设连贯，请在这里配置 Redis 的 IP 地址、端口号、明码和用到的 Key
            local rhost = "123.45.67.89"
            local rport = 6739
            local rpass = "abcdefg"
            local rkey = "proxy:pool"
            local ok, err = redis_instance:connect(rhost, rport)
            ngx.log(ngx.ERR, "1111111", ok, " ", err)

            -- 如果没有明码，移除上面这一行
            local res, err = redis_instance:auth(rpass)
            local res, err = redis_instance:hkeys(rkey)
            if not res then
                ngx.log(ngx.ERR,"res num error :", err)
                return redis_instance:close()
            end
            math.randomseed(tostring(ngx.now()):reverse():sub(1, 6))
            local proxy = res[math.random(#res)]
            local colon_index = string.find(proxy, ":")
            local proxy_ip = string.sub(proxy, 1, colon_index - 1)
            local proxy_port = string.sub(proxy, colon_index + 1)
            ngx.log(ngx.ERR,"redis data =", proxy_ip, ":", proxy_port);
            ngx.ctx.proxy_host = proxy_ip
            ngx.ctx.proxy_port = proxy_port
            redis_instance:close()}
        #  上面是本机的端口，也就是爬虫固定写死的端口
       listen 0.0.0.0:9976; #监听本机地址和端口，当应用 keeplived 的状况下应用 keeplived VIP
       proxy_connect_timeout 3s;
       proxy_timeout 10s;
       proxy_pass backend; #这里填写对端的地址
    }
}

须要批改的中央，我在配置文件外面曾经做好的正文。具体而言，须要批改中央蕴含：

• Redis 的地址、端口、明码和 Key。如果你的 Redis 没有明码，能够把设置明码的这一行删掉

• 入口代理的端口
  

设置好了这些配置当前，咱们就能够应用 Docker 来启动它。Docker 的配置文件极其简略：

from openresty/openresty:centos

copy nginx_redis.conf /usr/local/openresty/nginx/conf/nginx.conf

而后，执行命令构建和运行：

docker build --network host -t tunnel_proxy:0.01 .
docker run --name tunnel_proxy --network host -it tunnel_proxy:0.01

运行当前，你会看到 Docker 的命令行仿佛卡住了。这是失常申请。因为须要你有了申请，它才会输入内容。

当初，你能够用 Requests 赶快写一段代码来进行验证：

import requests
import time

proxies = {'http': 'http://13.88.220.207:9976'}
for _ in range(10):
    resp = requests.get('http://httpbin.org/ip', proxies=proxies).text
    print(resp)
    time.sleep(1)

运行成果如下图所示。

阐明隧道代理搭建胜利。目前隧道代理我曾经稳固运行了半年，素来没有出过问题，大家能够放心使用。

最初，本文受到 @萌木盖 的文章：openresty 正向代理搭建 – 简书的启发，并在该文章根底上进行改良。特别感谢原作者。

如果本文讲到的办法，能帮你节省下不少购买隧道代理的钱，那么请思考拿出其中的一小部分，退出我的常识星球，成为 未闻 Code·Pro 会员。

退出星球，你除了能取得在微信群中已有的全副福利外，还会额定取得：

1. 问题的优先解答和一对一答疑
2. 职业生涯规划征询
3. 面试技巧和教训
4. 定期发展的专属直播分享
5. 定期抽奖流动
6. ……