python如何做分布式爬虫

Python做分布式爬虫的方式包括：使用Scrapy框架、结合分布式任务队列Celery、使用分布式数据库如Redis、利用框架如PySpider、结合消息队列如RabbitMQ。 其中，Scrapy-Redis 是一种常用的解决方案，它将Scrapy与Redis结合，能够高效管理任务队列，实现去重，并支持断点续爬。接下来，我们将详细探讨其中的各个方法和步骤。

一、SCRAPY框架与SCRAPY-REDIS

1. Scrapy框架

Scrapy 是一个功能强大的Python爬虫框架，提供了丰富的组件来实现网页爬取、数据解析和存储。其核心组件包括Spider、Item、Pipeline、Downloader Middleware等。

Spider：定义爬取逻辑，指定初始URL和解析函数。
Item：定义数据结构，类似于数据库表的schema。
Pipeline：处理爬取到的数据，可以进行清洗、验证和存储。
Downloader Middleware：处理请求和响应的中间件，可以实现请求头设置、代理切换等功能。

使用Scrapy可以快速搭建单机爬虫，但要实现分布式爬虫，还需要引入Scrapy-Redis。

2. Scrapy-Redis

Scrapy-Redis 是一个扩展Scrapy的组件，主要功能包括：

任务队列：将待爬取的URL存储在Redis中，支持多个爬虫实例共享任务队列。
去重机制：使用Redis的set数据结构，实现URL去重。
断点续爬：任务队列和去重集合存储在Redis中，支持爬虫中断后继续爬取。

实现步骤：

安装Scrapy-Redis：
```
pip install scrapy-redis
```

修改Scrapy配置：

在Scrapy项目的settings.py中，添加如下配置：

# 启用Scrapy-Redis的调度器 SCHEDULER = "scrapy_redis.scheduler.Scheduler" 启用去重过滤器 DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter" 设置Redis的连接参数 REDIS_URL = 'redis://localhost:6379' 持久化任务队列，断点续爬 SCHEDULER_PERSIST = True

修改Spider：

将Spider类继承自scrapy_redis.spiders.RedisSpider，并定义redis_key。

from scrapy_redis.spiders import RedisSpider
class MySpider(RedisSpider):
    name = 'my_spider'
    redis_key = 'my_spider:start_urls'
    def parse(self, response):
        # 解析逻辑
        pass

启动Redis：

确保Redis服务已经启动，并且正确配置。
启动爬虫实例：

在多个终端上启动爬虫实例，可以实现分布式爬取。
```
scrapy crawl my_spider
```

二、结合分布式任务队列Celery

Celery 是一个分布式任务队列系统，支持任务异步执行和定时任务。结合Celery可以实现任务的分发和调度，适用于大规模分布式爬虫。

实现步骤：

安装Celery：
```
pip install celery
```

定义Celery任务：

创建一个tasks.py文件，定义爬虫任务。

from celery import Celery
from scrapy.crawler import CrawlerProcess
from my_scrapy_project.spiders.my_spider import MySpider
app = Celery('tasks', broker='redis://localhost:6379/0')
@app.task
def run_spider():
    process = CrawlerProcess()
    process.crawl(MySpider)
    process.start()

启动Celery Worker：

启动Celery worker，监听任务队列。
```
celery -A tasks worker --loglevel=info
```
分发任务：

可以在任务生成端分发爬虫任务。
```
from tasks import run_spider
run_spider.delay()
```

三、使用分布式数据库如Redis

Redis除了作为任务队列，还可以存储爬取的数据，实现分布式存储。

实现步骤：

配置Redis Pipeline：

在Scrapy项目的settings.py中，配置RedisPipeline。

ITEM_PIPELINES = {
    'scrapy_redis.pipelines.RedisPipeline': 300,
}
REDIS_ITEMS_KEY = 'my_spider:items'

定义Item：

定义爬取的数据结构。

import scrapy
class MyItem(scrapy.Item):
    title = scrapy.Field()
    url = scrapy.Field()

解析并存储数据：

在Spider中解析数据，并将Item传递给Pipeline。

from my_scrapy_project.items import MyItem
def parse(self, response):
    item = MyItem()
    item['title'] = response.xpath('//title/text()').get()
    item['url'] = response.url
    yield item

四、利用框架如PySpider

PySpider 是另一个功能强大的爬虫框架，支持WebUI管理、任务调度和分布式爬取。

实现步骤：

安装PySpider：
```
pip install pyspider
```
启动PySpider：

启动PySpider的WebUI和任务调度服务。
```
pyspider all
```

编写爬虫脚本：

在WebUI中编写爬虫脚本。

from pyspider.libs.base_handler import *
class Handler(BaseHandler):
    crawl_config = {}
    @every(minutes=24 * 60)
    def on_start(self):
        self.crawl('http://example.com', callback=self.index_page)
    def index_page(self, response):
        for each in response.doc('a[href^="http"]').items():
            self.crawl(each.attr.href, callback=self.detail_page)
    def detail_page(self, response):
        return {
            "url": response.url,
            "title": response.doc('title').text(),
        }

启动爬虫任务：

在WebUI中启动爬虫任务，可以监控任务进度和结果。

五、结合消息队列如RabbitMQ

RabbitMQ 是一个高性能的消息队列系统，可以用于任务分发和调度。

实现步骤：

安装RabbitMQ：

安装RabbitMQ服务，并启动RabbitMQ。

sudo apt-get install rabbitmq-server sudo service rabbitmq-server start

安装Pika：

Pika是RabbitMQ的Python客户端库。
```
pip install pika
```

定义消息生产者：

创建一个producer.py文件，定义消息生产者。

import pika
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='task_queue', durable=True)
def send_message(message):
    channel.basic_publish(
        exchange='',
        routing_key='task_queue',
        body=message,
        properties=pika.BasicProperties(
            delivery_mode=2,  # make message persistent
        ))
    print(" [x] Sent %r" % message)
connection.close()

定义消息消费者：

创建一个consumer.py文件，定义消息消费者。

import pika
from scrapy.crawler import CrawlerProcess
from my_scrapy_project.spiders.my_spider import MySpider
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='task_queue', durable=True)
def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    process = CrawlerProcess()
    process.crawl(MySpider)
    process.start()
    ch.basic_ack(delivery_tag=method.delivery_tag)
channel.basic_qos(prefetch_count=1)
channel.basic_consume(queue='task_queue', on_message_callback=callback)
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

发送任务消息：

运行producer.py发送任务消息，运行consumer.py处理任务。

通过上述方法，可以实现Python的分布式爬虫。每种方法各有优缺点，可以根据具体需求选择合适的方案。使用Scrapy-Redis是一个较为简单和高效的方案，适合大多数场景；使用Celery和RabbitMQ则适合对任务调度和分发有更高需求的场景；PySpider则提供了一个易于管理的WebUI，非常适合中小型爬虫项目。