基于后端和爬虫创建的代理ip池

搭建免费的代理ip池

需要解决的问题:

• 使用什么方式存储ip
  
  
  
  • 文件存储
    缺点: 打开文件修改文件操作较麻烦
    
  • mysql
    缺点: 查询速度较慢
    
  • mongodb
    缺点: 查询速度较慢. 没有查重功能
    
  • redis  --> 使用redis存储最为合适
    
  所以 -> 数据结构采用redis中的zset有序集合
  
  
• 获取ip的网站
  
  
  
  • https://ip.jiangxianli.com/
    
  • https://free.kuaidaili.com/free/intr/
    
  
  
• 项目架构？？？
  

项目架构

• 获取api
  
• 筛选api
  
• 验证api的有效性
  
• 提供api
  

项目结构图

项目结构如下:

项目代码

code文件夹

redis_proxy.py

1. # -*- encoding:utf-8 -*-
2. # @time: 2022/7/4 11:32
3. # @author: Maxs_hu
4. """
5. 这里用来做redis中间商. 去控制redis和ip之间的调用关系
6. """
7. from redis import Redis
8. import random
11. class RedisProxy:
12.     def __init__(self):
13.         # 连接到redis数据库
14.         self.red = Redis(
15.             host='localhost',
16.             port=6379,
17.             db=9,
18.             password=123456,
19.             decode_responses=True
20.         )
22.     # 1. 存储到redis中. 存储之前需要提前判断ip是否存在. 防止将已存在的ip的score抵掉
23.     # 2. 需要校验所有的ip. 查询ip
24.     # 3. 验证可用性. 可用分值拉满. 不可用扣分
25.     # 4. 将可用的ip查出来返回给用户
26.     #       先给满分的
27.     #       再给有分的
28.     #       都没有分. 就不给
30.     def add_ip(self, ip):  # 外界调用并传入ip
31.         # 判断ip在redis中是否存在
32.         if not self.red.zscore('proxy_ip', ip):
33.             self.red.zadd('proxy_ip', {ip: 10})
34.             print('proxy_ip存储完毕', ip)
35.         else:
36.             print('存在重复', ip)
38.     def get_all_proxy(self):
39.         # 查询所有的ip功能
40.         return self.red.zrange('proxy_ip', 0, -1)
42.     def set_max_score(self, ip):
43.         self.red.zadd('proxy_ip', {ip: 100})  # 注意是引号的格式
45.     def deduct_score(self, ip):
46.         # 先将分数查询出来
47.         score = self.red.zscore('proxy_ip', ip)
48.         # 如果有分值.那就扣一分
49.         if score > 0:
50.             self.red.zincrby('proxy_ip', -1, ip)
51.         else:
52.             # 如果分值已经扣的小于0了. 那么可以直接删除了
53.             self.red.zrem('proxy_ip', ip)
55.     def effect_ip(self):
56.         # 先将ip通过分数筛选出来
57.         ips = self.red.zrangebyscore('proxy_ip', 100, 100, 0, -1)
58.         if ips:
59.             return random.choice(ips)
60.         else:  # 没有满分的
61.             # 将九十分以上的筛选出来
62.             ips = self.red.zrangebyscore('proxy_ip', 11, 99, 0, -1)
63.             if ips:
64.                 return random.choice(ips)
65.             else:
66.                 print('无可用ip')
67.                 return None

复制代码

ip_collection.py

1. # -*- encoding:utf-8 -*-
2. # @time: 2022/7/4 11:32
3. # @author: Maxs_hu
4. """
5. 这里用来收集ip
6. """
7. from redis_proxy import RedisProxy
8. import requests
9. from lxml import html
10. from multiprocessing import Process
11. import time
12. import random
15. def get_kuai_ip(red):
16.     url = "https://free.kuaidaili.com/free/intr/"
17.     headers = {
18.         "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36"
19.     }
20.     resp = requests.get(url, headers=headers)
21.     etree = html.etree
22.     et = etree.HTML(resp.text)
23.     trs = et.xpath('//table//tr')
24.     for tr in trs:
25.         ip = tr.xpath('./td[1]/text()')
26.         port = tr.xpath('./td[2]/text()')
27.         if not ip:  # 将不含有ip值的筛除
28.             continue
29.         proxy_ip = ip[0] + ":" + port[0]
30.         red.add_ip(proxy_ip)
33. def get_unknown_ip(red):
34.     url = "https://ip.jiangxianli.com/"
35.     headers = {
36.         "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36"
37.     }
38.     resp = requests.get(url, headers=headers)
39.     etree = html.etree
40.     et = etree.HTML(resp.text)
41.     trs = et.xpath('//table//tr')
42.     for tr in trs:
43.         ip = tr.xpath('./td[1]/text()')
44.         port = tr.xpath('./td[2]/text()')
45.         if not ip:  # 将不含有ip值的筛除
46.             continue
47.         proxy_ip = ip[0] + ":" + port[0]
48.         red.add_ip(proxy_ip)
51. def get_happy_ip(red):
52.     page = random.randint(1, 5)
53.     url = f'http://www.kxdaili.com/dailiip/2/{page}.html'
54.     headers = {
55.         "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36"
56.     }
57.     resp = requests.get(url, headers=headers)
58.     etree = html.etree
59.     et = etree.HTML(resp.text)
60.     trs = et.xpath('//table//tr')
61.     for tr in trs:
62.         ip = tr.xpath('./td[1]/text()')
63.         port = tr.xpath('./td[2]/text()')
64.         if not ip:  # 将不含有ip值的筛除
65.             continue
66.         proxy_ip = ip[0] + ":" + port[0]
67.         red.add_ip(proxy_ip)
70. def get_nima_ip(red):
71.     url = 'http://www.nimadaili.com/'
72.     headers = {
73.         "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36"
74.     }
75.     resp = requests.get(url, headers=headers)
76.     etree = html.etree
77.     et = etree.HTML(resp.text)
78.     trs = et.xpath('//table//tr')
79.     for tr in trs:
80.         ip = tr.xpath('./td[1]/text()')  # 这里存在空值. 所以不能在后面加[0]
81.         if not ip:
82.             continue
83.         red.add_ip(ip[0])
86. def get_89_ip(red):
87.     page = random.randint(1, 26)
88.     url = f'https://www.89ip.cn/index_{page}.html'
89.     headers = {
90.         "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36"
91.     }
92.     resp = requests.get(url, headers=headers)
93.     etree = html.etree
94.     et = etree.HTML(resp.text)
95.     trs = et.xpath('//table//tr')
96.     for tr in trs:
97.         ip = tr.xpath('./td[1]/text()')
98.         if not ip:
99.             continue
100.         red.add_ip(ip[0].strip())
103. def main():
104.     # 创建一个redis实例化对象
105.     red = RedisProxy()
106.     print("开始采集数据")
107.     while 1:
108.         try:
109.             # 这里可以添加各种采集的网站
110.             print('>>>开始收集快代理ip')
111.             get_kuai_ip(red)  # 收集快代理
112.             # get_unknown_ip(red)  # 收集ip
113.             print(">>>开始收集开心代理ip")
114.             get_happy_ip(red)  # 收集开心代理
115.             print(">>>开始收集泥马代理ip")
116.             # get_nima_ip(red)  # 收集泥马代理
117.             print(">>>开始收集89代理ip")
118.             get_89_ip(red)
119.             time.sleep(60)
120.         except Exception as e:
121.             print('ip储存出错了', e)
122.             time.sleep(60)
125. if __name__ == '__main__':
126.     main()
127.     # 创建一个子进程
128.     # p = Process(target=main)
129.     # p.start()

复制代码

ip_verify.py

1. # -*- encoding:utf-8 -*-
2. # @time: 2022/7/4 11:34
3. # @author: Maxs_hu
4. """
5. 这里用来验证ip的可用性: 使用携程发送请求增加效率
6. """
7. from redis_proxy import RedisProxy
8. from multiprocessing import Process
9. import asyncio
10. import aiohttp
11. import time
14. async def verify_ip(ip, red, sem):
15.     timeout = aiohttp.ClientTimeout(total=10)  # 设置网页等待时间不超过十秒
16.     try:
17.         async with sem:
18.             async with aiohttp.ClientSession() as session:
19.                 async with session.get(url='http://www.baidu.com/',
20.                                        proxy='http://'+ip,
21.                                        timeout=timeout) as resp:
22.                     page_source = await resp.text()
23.                     if resp.status in [200, 302]:
24.                         # 如果可用. 加分
25.                         red.set_max_score(ip)
26.                         print('验证没有问题. 分值拉满~', ip)
27.                     else:
28.                         # 如果不可用. 扣分
29.                         red.deduct_score(ip)
30.                         print('问题ip. 扣一分', ip)
31.     except Exception as e:
32.         print('出错了', e)
33.         red.deduct_score(ip)
34.         print('问题ip. 扣一分', ip)
37. async def task(red):
38.     ips = red.get_all_proxy()
39.     sem = asyncio.Semaphore(30)  # 设置每次三十的信号量
40.     tasks = []
41.     for ip in ips:
42.         tasks.append(asyncio.create_task(verify_ip(ip, red, sem)))
43.     if tasks:
44.         await asyncio.wait(tasks)
47. def main():
48.     red = RedisProxy()
49.     time.sleep(5)  # 初始的等待时间. 等待采集到数据
50.     print("开始验证可用性")
51.     while 1:
52.         try:
53.             asyncio.run(task(red))
54.             time.sleep(100)
55.         except Exception as e:
56.             print("ip_verify出错了", e)
57.             time.sleep(100)
60. if __name__ == '__main__':
61.     main()
62.     # 创建一个子进程
63.     # p = Process(target=main())
64.     # p.start()

复制代码

ip_api.py

1. # -*- encoding:utf-8 -*-
2. # @time: 2022/7/4 11:35
3. # @author: Maxs_hu
5. """
6. 这里用来提供给用户ip接口. 通过写后台服务器. 用户访问我们的服务器就可以得到可用的代理ip:
7.    1. flask
8.    2. sanic --> 今天使用这个要稍微简单一点
9. """
10. from redis_proxy import RedisProxy
11. from sanic import Sanic, json
12. from sanic_cors import CORS
13. from multiprocessing import Process
15. # 创建一个app
16. app = Sanic('ip')  # 随便给个名字
17. # 解决跨域问题
18. CORS(app)
19. red = RedisProxy()
22. @app.route('maxs_hu_ip')  # 添加路由
23. def api(req):  # 第一个请求参数固定. 请求对象
24.    ip = red.effect_ip()
25.    return json({"ip": ip})
28. def main():
29.    # 让sanic跑起来
30.    app.run(host='127.0.0.1', port=1234)
33. if __name__ == '__main__':
34.    main()
35.    # p = Process(target=main())
36.    # p.start()

复制代码

runner.py

1. # -*- encoding:utf-8 -*-
2. # @time: 2022/7/5 17:36
3. # @author: Maxs_hu
4. from ip_api import main as api_run
5. from ip_collection import main as coll_run
6. from ip_verify import main as veri_run
7. from multiprocessing import Process
10. def main():
11.     # 设置互不干扰的三个进程
12.     p1 = Process(target=api_run)  # 只需要将目标函数的内存地址传过去即可
13.     p2 = Process(target=coll_run)
14.     p3 = Process(target=veri_run)
16.     p1.start()
17.     p2.start()
18.     p3.start()
21. if __name__ == '__main__':
22.     main()

复制代码

测试ip是否可用.py

1. # -*- encoding:utf-8 -*-
2. # @time: 2022/7/5 18:15
3. # @author: Maxs_hu
4. import requests
7. def get_proxy():
8.     url = "http://127.0.0.1:1234/maxs_hu_ip"
9.     resp = requests.get(url)
10.     return resp.json()
13. def main():
14.     url = 'http://mip.chinaz.com/?query=' + get_proxy()["ip"]
15.     proxies = {
16.         "http": 'http://' + get_proxy()["ip"],
17.         "https": 'http://' + get_proxy()["ip"]  # 目前代理只支持http请求
18.     }
19.     headers = {
20.         "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36",
21.     }
22.     resp = requests.get(url, proxies=proxies, headers=headers)
23.     resp.encoding = 'utf-8'
24.     print(resp.text)  # 物理位置
27. if __name__ == '__main__':
28.     main()

复制代码

运行效果

项目运行截图:

redis储存截图:

总结

• 免费代理ip只支持http的网页操作. 并不好用. 如果有需求可以进行购买然后加入ip代理池
  
• 网页部署到自己的服务器上. 别人访问自己的服务器. 以后学了全栈可以加上登录. 和付费功能. 实现功能的进一步拓展
  
• 项目架构是生产者消费者模型. 三个模块同时运行. 每个模块为一个进程. 互不影响
  
• 代理设计细节有待处理. 但总体运行效果还可以. 遇到问题再修改
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！