При масштабировании процессов веб-скрапинга вам необходимо рассмотреть возможность использования надежного, эффективного и управляемого решения, независимо от объема собираемых данных.

Большинство разработчиков считают сложным заниматься обширным скрапингом из-за огромного объема вовлеченных данных. Ваш код, который отлично работал для небольших проектов, внезапно начинает ломаться, блокироваться или его становится невозможно поддерживать.

Вот где Crawlbase приходит. Наше решение разработано специально для облегчения плавного перехода. Вам больше не придется переписывать все с нуля или полностью менять свой рабочий процесс. Как? Мы покажем вам в мельчайших подробностях.

Содержание

  1. Почему масштабирование имеет значение при веб-скрапинге

  2. Как выбрать между синхронным и асинхронным веб-скрапингом

  1. Как настроить масштабируемое Crawler
  1. Как справиться с крупномасштабной обработкой данных
  1. Crawler Техническое обслуживание и мониторинг

  1. Масштабируйте свой веб-скрапинг с помощью Crawlbase

  2. Часто задаваемые вопросы (FAQ)

Почему масштабирование имеет значение при веб-скрапинге

В небольших масштабах процесс веб-скрейпинга прост. Вы пишете скрипт, отправляете запрос на несколько веб-страниц, и ваш скрапер выполняет работу последовательно. Однако как только вы пытаетесь увеличить масштаб своего проекта, чтобы скрапинговать тысячи или даже миллионы страниц, все начинает разваливаться.

Масштабирование — это не просто выполнение того же самого, а нечто большее. Это выполнение с умом. Вам следует помнить о распространенных проблемах масштабирования, таких как:

  • Ограничение скорости
  • Проблемы параллелизма
  • Повторите вызовы
  • Проблемы эффективности кода
  • Ограничения по хранению

Если вы проигнорируете эти проблемы, ваш парсер может работать сегодня, но завтра он выйдет из строя, когда ваши потребности в данных возрастут или когда изменится целевой сайт.

Одно из первых решений, которое вам нужно будет принять, — использовать ли синхронный или асинхронный скрапинг. Этот выбор сам по себе может радикально решить большинство проблем масштабирования и повлиять на то, насколько быстро и эффективно вы масштабируетесь.

Как выбрать между синхронным и асинхронным веб-скрапингом

При создании масштабируемого скрапера важно то, как вы отправляете и обрабатываете запросы. В небольших проектах синхронный скрапинг может быть приемлемым. Однако по мере масштабирования выбор правильного подхода может стать разницей между быстрым и эффективным скрапером и тем, который зависнет или заблокируется.

Синхронный веб-скрапинг

Синхронный скрапинг — очень простой процесс. Вы отправляете запрос, ждете ответа, обрабатываете данные, а затем переходите к следующему. Все происходит по одному шагу за раз, как будто вы стоите в очереди и ждете своей очереди.

Этот подход прост в реализации и отлично подходит для небольших работ или тестирования, поскольку:

  • Код прост для чтения и отладки.
  • Легче управлять ошибками, поскольку запросы выполняются в определенном порядке.
  • Вам не придется беспокоиться о параллелизме или координации задач.

CrawlbaseАвтора Crawling API — яркий пример синхронного краулера, который выполняет свою работу. Но по мере масштабирования синхронное сканирование может стать узким местом. Ваш скребок тратит много времени, просто ожидая ответа серверов, ожидая тайм-аутов, ожидая повторных попыток. И все это ожидание накапливается.

Асинхронный веб-скрапинг

Асинхронный скрапинг означает, что вы можете отправлять несколько запросов, и система обрабатывает или выполняет эти запросы одновременно, а не ждет завершения каждого из них перед выполнением следующего запроса. Этот подход необходим для масштабирования, поскольку он устраняет время простоя, затрачиваемое на ожидание ответов сети.

На практике это означает более высокую пропускную способность, лучшее использование ресурсов и возможность быстрее извлекать большие объемы данных.

Crawlbase предоставляет специально разработанную асинхронную систему сканирования и сбора данных, известную просто как Crawler. Он разработан для обработки больших объемов данных, позволяя вам отправлять несколько URL-адресов для одновременного сканирования без необходимости управления сложной инфраструктурой.

Вот как это работает:

  • Команда Crawler это push-система, основанная на обратных вызовах.
  • Вы отправляете URL-адреса для копирования в Crawler используя Crawling API.
  • Каждому запросу присваивается RID (идентификатор запроса), что помогает отслеживать его на протяжении всего процесса.
  • Любые неудачные запросы будут автоматически повторяться до тех пор, пока не будет получен допустимый ответ.
  • Команда Crawler ОТПРАВИТ результаты обратно на URL-адрес веб-хука на вашем сервере.

Команда Crawler дает вам мощный способ реализации асинхронного скрапинга. Параллельная обработка нескольких страниц и автоматическое повторение неудачных запросов. Это означает одновременное решение проблем ограничения скорости, параллелизма и повтора.

Что следует сделать для масштабирования веб-скрапинга?

CrawlbaseАвтора Crawling API — отличный инструмент, который надежно обрабатывает миллионы запросов. Он разработан для крупномасштабного скрапинга и отлично работает, если вам нужны прямые, немедленные ответы на каждый запрос. Он прост в реализации и идеально подходит для небольших и средних по размеру задач, быстрых скриптов и интеграций, где результаты в реальном времени имеют решающее значение.

Однако когда вы имеете дело с очисткой данных на уровне предприятия, миллионами URL-адресов, жесткими требованиями к параллельности и необходимостью надежной организации очередей, использование Crawler имеет гораздо больше смысла.

Команда Crawler предназначен для сбора больших объемов данных. Он масштабируется по своей конструкции, поддерживает параллельную обработку и автоматические повторные попытки, а также может расти вместе с вашими потребностями.

Итак, вот как следует масштабировать:

Создайте масштабируемый скрапер с помощью Crawling API когда ты:

  • Нужны результаты в реальном времени
  • Выполняете ли вы небольшие заказы?
  • Предпочитает более простую модель «запрос-ответ»

Затем перейдите к Crawler когда ты:

  • Необходимо обработать тысячи или миллионы URL-адресов
  • Хотите обрабатывать несколько запросов одновременно?
  • Хотите разгрузить процесс повторных попыток с вашей стороны?
  • Вы создаете масштабируемый конвейер данных производственного уровня?

Короче говоря, если ваша цель — настоящая масштабируемость, переход от синхронного к асинхронному скрапингу с помощью Crawler это лучший выбор.

Как настроить масштабируемое Crawler

В этом разделе мы предоставим вам пошаговое руководство, включая лучшие практики по созданию масштабируемого веб-скрейпера. Обратите внимание, что мы решили продемонстрировать это с помощью Python с Flask и Официантка, так как этот метод является и легким, и простым в реализации.

Давай начнем.

Требования к Python

  • Настройте базовую среду Python. Установите Python 3 в вашей системе.
  • Установите требуемые зависимости. Вы можете скачать этот файл и выполнить команду ниже в своем терминале:
1
python -m pip install запросы flask waitress

Интеграция вебхука

Шаг 1: Создайте файл и дайте ему имя. webhook_http_server.py, затем скопируйте и вставьте приведенный ниже код:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
от колба Импортировать Flask

от колба Импортировать запросить
от библиотека путей Импортировать Тропа
Импортировать GZIP
Импортировать JSON
Импортировать os
Импортировать нарезания резьбы

REQUEST_SECURITY_ID = '8e1c3efb29fcc59d3c61f86960ccc9f5'

приложение = Flask("webhook_http_server")

защиту handle_webhook_request(запрос_контента):
    # Реализацию обсудим позже
    pass

@app.route("/вебхук", методы=["СООБЩЕНИЕ"])
защиту перехватчик():
    if 'избавлять' не in заголовки запроса or «Оригинальный статус» не in заголовки запроса or «Статус ПК» не in заголовки запроса:
        возвращают ("", 404)

    crawlbase_rid = запрос.заголовки.получить("избавлять")

    if crawlbase_rid == "dummyrequest":
        Распечатать("- Получен фиктивный запрос от Crawlbase.")
        возвращают ("", 204)

    if запрос.заголовки.получить(«Мой-Ид») != ЗАПРОС_БЕЗОПАСНОСТИ_ИД:
        возвращают ("", 404)

    запрос_контента = (
        crawlbase_rid,
        запрос.заголовки.получить("URL"),
        запрос.заголовки.получить(«Исходный-Статус»),
        запрос.заголовки.получить("PC-Статус"),
        запрос.заголовки.получить(«Контент-кодирование»),
        запрос.данных
    )

    поток = threading.Thread(target=handle_webhook_request, args=(request_content,))
    thread.start ()

    возвращают ("", 204)

Рассматривая код выше, можно увидеть несколько хороших практик, которым мы следуем при работе с веб-хуками:

  • Мы принимаем HTTP POST запросы, что является стандартом для веб-хуков.
  • Мы проверяем наличие важных заголовков, таких как rid, Original-Status и PC-Status от Crawlbase ответ чтобы убедиться, что запрос содержит правильную информацию.
  • Мы игнорируем фиктивные запросы от Crawlbase. Это просто «контрольные» сообщения, отправляемые для проверки работоспособности вашего веб-хука.
  • Мы также ищем индивидуальный заголовок. My-Id со значением константы REQUEST_SECURITY_ID. Это значение — просто строка, вы можете придумать что угодно для дополнительной безопасности. Использование этого заголовка — лучшая практика для защита вашего вебхука, поскольку он проверяет подлинность входящих ответов и их предназначение именно вам.
  • Наконец, фактические задания обрабатываются в отдельном потоке, что позволяет нам быстро отвечать в течение 200 мс. Эта настройка должна быть способна обрабатывать около 200 запросов в секунду без проблем.

Шаг 2: Добавьте оставшуюся часть кода ниже. Это то, где находятся фактические данные из Crawlbase обрабатывается и сохраняется. Для простоты мы используем файловую систему для отслеживания просканированных запросов. В качестве альтернативы вы можете использовать база данных или Редис.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
защиту handle_webhook_request(запрос_контента):
    crawlbase_rid = request_content[0]
    запрошенный_url = запрос_контента[1]
    оригинальный_статус = запрос_контента[2]
    crawlbase_status = request_content[3]
    content_encoding = request_content[4]
    тело = запрос_контент[5]

    if content_encoding == "gzip":
        стараться:
            тело = gzip.decompress(тело)
        кроме исключение:
            pass

    стараться:
        data_dir = os.path.join(Path.cwd(), "данные")
        if не os.path.isdir(каталог_данных):
            Путь(data_dir).mkdir(parents=Правда, существует_ok=Правда)

        rid_dir = os.path.join(data_dir, crawlbase_rid)
        if не os.path.isdir(rid_dir):
            Путь(rid_dir).mkdir(родители=Правда, существует_ok=Правда)

        мета = {"избавлять": crawlbase_rid, "запрошенный_url": запрошенный_url, "исходный_статус": оригинальный_статус, "crawlbase_status": crawlbase_status}
        meta_file = os.path.join(rid_dir, f"{crawlbase_rid}.meta.json")
        с открытый(мета_файл, "ш") as f:
            pretty_json = json.dumps(meta, indent=2)
            f.write(pretty_json)

        body_file = os.path.join(rid_dir, crawlbase_rid)
        с открытый(файл_тела, "вб") as f:
            f.write(тело)

        Распечатать(f"- Успешно обработан RID {crawlbase_rid}. Вывод сохранен в '{rid_dir}»«.)
    кроме Исключение as e:
        Распечатать(f"- Произошла ошибка при обработке {crawlbase_rid}:\н{е}")

Эта часть кода аккуратно распаковывает завершенное задание сканирования из Crawlbase, организует файлы в отдельной папке, сохраняет как заметки, так и фактические данные веб-сайта и уведомляет вас, если что-то пойдет не так.

Шаг 3: Завершите код, настроив пакет официантки для запуска сервера. Здесь мы используем порт 5768 для прослушивания входящих запросов, но вы можете изменить это значение на любое другое по вашему желанию.

1
2
3
4
5
6
if __имя__ == "__основной__":
    от официантка Импортировать служить
    хост = "0.0.0.0"
    порт= 5768
    Распечатать(f"\n\n- HTTP-сервер Webhook работает на {хозяин}:{порт}.\n\n")
    serve(приложение, хост=хост, порт=порт)

Вот как выглядит полный сценарий для нашего webhook_http_server.py выглядит как:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
от колба Импортировать Flask

от колба Импортировать запросить
от библиотека путей Импортировать Тропа
Импортировать GZIP
Импортировать JSON
Импортировать os
Импортировать нарезания резьбы

REQUEST_SECURITY_ID = '8e1c3efb29fcc59d3c61f86960ccc9f5'

приложение = Flask("webhook_http_server")

защиту handle_webhook_request(запрос_контента):
    crawlbase_rid = request_content[0]
    запрошенный_url = запрос_контента[1]
    оригинальный_статус = запрос_контента[2]
    crawlbase_status = request_content[3]
    content_encoding = request_content[4]
    тело = запрос_контент[5]

    if content_encoding == "gzip":
        стараться:
            тело = gzip.decompress(тело)
        кроме исключение:
            pass

    стараться:
        data_dir = os.path.join(Path.cwd(), "данные")
        if не os.path.isdir(каталог_данных):
            Путь(data_dir).mkdir(parents=Правда, существует_ok=Правда)

        rid_dir = os.path.join(data_dir, crawlbase_rid)
        if не os.path.isdir(rid_dir):
            Путь(rid_dir).mkdir(родители=Правда, существует_ok=Правда)

        мета = {"избавлять": crawlbase_rid, "запрошенный_url": запрошенный_url, "исходный_статус": оригинальный_статус, "crawlbase_status": crawlbase_status}
        meta_file = os.path.join(rid_dir, f"{crawlbase_rid}.meta.json")
        с открытый(мета_файл, "ш") as f:
            pretty_json = json.dumps(meta, indent=2)
            f.write(pretty_json)

        body_file = os.path.join(rid_dir, crawlbase_rid)
        с открытый(файл_тела, "вб") as f:
            f.write(тело)

        Распечатать(f"- Успешно обработан RID {crawlbase_rid}. Вывод сохранен в '{rid_dir}»«.)
    кроме Исключение as e:
        Распечатать(f"- Произошла ошибка при обработке {crawlbase_rid}:\н{е}")

@app.route("/вебхук", методы=["СООБЩЕНИЕ"])
защиту перехватчик():
    if «Оригинальный статус» не in заголовки запроса or «Статус ПК» не in заголовки запроса or 'избавлять' не in заголовки запроса:
        возвращают ("", 404)

    crawlbase_rid = запрос.заголовки.получить("избавлять")

    if crawlbase_rid == "dummyrequest":
        Распечатать("- Получен фиктивный запрос от Crawlbase.")
        возвращают ("", 204)

    if запрос.заголовки.получить(«Мой-Ид») != ЗАПРОС_БЕЗОПАСНОСТИ_ИД:
        возвращают ("", 404)

    запрос_контента = (
        crawlbase_rid,
        запрос.заголовки.получить("URL"),
        запрос.заголовки.получить(«Исходный-Статус»),
        запрос.заголовки.получить("PC-Статус"),
        запрос.заголовки.получить(«Контент-кодирование»),
        запрос.данных
    )

    поток = threading.Thread(target=handle_webhook_request, args=(request_content,))
    thread.start ()

    возвращают ("", 204)


if __имя__ == "__основной__":

    от официантка Импортировать служить
    хост = "0.0.0.0"
    порт= 5768
    Распечатать(f"\n\n- HTTP-сервер Webhook работает на {хозяин}:{порт}.\n\n")
    serve(приложение, хост=хост, порт=порт)

Шаг 4: Используйте команду ниже, чтобы запустить наш временный публичный сервер.

1
нгрок http 5768

ngrok даст вам ссылку или «URL-адрес пересылки» Вы можете поделиться с Crawlbase поэтому он знает, куда отправлять результаты.

Скриншот вывода ngrok

Наконечник: Если вы хотите использовать это в производстве (а не только для тестирования), лучше запустить свой вебхук на публичном сервере и использовать такой инструмент, как Nginx для безопасности и надежности.

Шаг 5: Запустите HTTP-сервер Webhook.

1
python webhook_http_server.py

Это теперь инициирует наш HTTP-сервер WebHook, готовый принимать данные от Crawlbase.

Скриншот вывода HTTP-сервера Webhook

Шаг 6. Настройте свой Crawlbase Счет.

  • Подписаться для Crawlbase счета и добавьте ваши платежные реквизиты для активации Crawler.
  • Создать новый Crawler здесь. Скопируйте URL-адрес переадресации, предоставленный ngrok ранее на шаге 4, и вставьте его в поле URL-адрес обратного вызова.
  • Выберите Обычные запросы (TCP) для целей данного руководства.
Скриншот для создания нового Crawler

Как справиться с крупномасштабной обработкой данных

Теперь, когда наш вебхук в сети, мы готовы к масштабному скрейпингу веб-сайтов. Мы напишем скрипт, который позволит вам быстро отправить список веб-сайтов Crawlbase. Он также будет автоматически повторять запросы в случае возникновения временных проблем.

Шаг 1: Базовый запрос на сканирование

Создайте новый файл Python и назовите его crawl.py

Скопируйте и вставьте этот код:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
от библиотека путей Импортировать Тропа
Импортировать JSON
Импортировать os
Импортировать Запросы
Импортировать urllib.parse

защиту ползать(URL):
    url = url.strip()
    encoded_url = urllib.parse.quote(url, safe="")
    encoded_crawlbase_crawler_name = urllib.parse.quote(CRAWLBASE_CRAWLER_NAME, safe="")
    encoded_callback_headers = urllib.parse.quote(f"МОЙ-ИДЕНТИФИКАТОР:{REQUEST_SECURITY_ID}", безопасно="")

    api_url = CRAWLBASE_CRAWLING_API_URL.формат(CRAWLBASE_TOKEN, закодированный_url, закодированное_имя_базы_сканера_сканирования, закодированные_заголовки_обратных_вызовов)

    стараться:
        ответ = запросы.получить(api_url)
        ответ.raise_for_status()
        json_response = json.loads(response.text)
        crawlbase_rid = json_response["избавлять"]

        data_dir = os.path.join(Path.cwd(), "данные")
        Путь(data_dir).mkdir(parents=Правда, существует_ok=Правда)

        rid_dir = os.path.join(data_dir, crawlbase_rid)
        Путь(rid_dir).mkdir(родители=Правда, существует_ok=Правда)

        Распечатать(f"- Запрос на сканирование для '{URL}' был успешно отправлен.")

    кроме Исключение as e:
        Распечатать(f"- Произошла ошибка при обработке '{URL}':\n{е}")

Что происходит в этой части сценария?

После того, как каждый запрос на сканирование отправляется Crawlbase, он создает специальную папку с именем rid. Такой подход позволяет отслеживать запросы на сканирование, что упрощает сопоставление результатов с их исходными URL-адресами в дальнейшем.

Кроме того, при отправке запроса мы добавляем пользовательский заголовок, который называется My-Id со стоимостью REQUEST_SECURITY_ID.

Шаг 2: Обработка ошибок и логика повтора

При написании масштабируемого скрапера всегда проверяйте, может ли он обрабатывать ошибки и включать какую-то логику для повторения любых неудачных запросов. Если вы не справитесь с этими проблемами, весь ваш процесс может остановиться из-за одного незначительного сбоя.

Рассмотрим пример:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Импортировать время

РАЗМЕР_ПАКЕТА = 100
DELAY_SECONDS = 1

защиту повторная_операция(операция, max_retries=3, задержка=2):
    для попытка in ассортимент(1, макс_повторений + 1):
        стараться:
            возвращают операция()
        кроме Исключение as e:
            Распечатать(f"- Ошибка при повторной попытке '{пытаться}':\n{е}")

        if попытка < max_retries:
            Распечатать(f"- Повторная попытка {задерживать} секунд...")
            время.сна(задержка)

    повышение Исключение(«Превышено максимальное количество попыток».)

Оберните ваш веб-запрос в retry_operation функция, гарантирующая автоматический повтор попытки до max_retries раз в случае возникновения ошибок.

1
2
3
4
5
6
защиту выполнить_запрос():
    ответ = запросы.получить(api_url)
    ответ.raise_for_status()
    возвращают ответ

ответ = повтор_операции(лямбда: выполнить_запрос())

Шаг 3: Метод пакетной обработки

При отправке тысяч URL-адресов, хорошей идеей будет объединить URL-адреса в небольшие группы и отправлять только определенное количество запросов за раз. Мы будем контролировать это через BATCH_SIZE значение в секунду.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
защиту пакетное_сканирование(URL-адреса):
    темы = []

    для URL in URL-адреса:
        t = поток.Thread(target=crawl, args=(url,))
        нити.append(t)
        т.старт()

    для t in темы:
        т.присоединиться()

защиту сканировать_urls(URL-адреса):
    для i in ассортимент(0, только(urls), BATCH_SIZE):
        batched_urls = urls[i:i + BATCH_SIZE]
        Распечатать(пакетные_urls)
        пакетное_сканирование(batched_urls)
        время.сна(DELAY_SECONDS)

В этом разделе несколько запросов в пакете обрабатываются одновременно для ускорения процесса. После завершения пакета скрипт ждет короткое время (DELAY_SECONDS) перед началом работы со следующей партией. Это эффективный метод обработки веб-скрапинга в масштабе.

Вот полный код. Скопируйте его и перезапишите код в вашем crawl.py .

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
от библиотека путей Импортировать Тропа
Импортировать JSON
Импортировать os
Импортировать Запросы
Импортировать нарезания резьбы
Импортировать время
Импортировать urllib.parse

CRAWLBASE_TOKEN = " "
CRAWLBASE_CRAWLER_NAME = "<Crawler имя> "

REQUEST_SECURITY_ID = '8e1c3efb29fcc59d3c61f86960ccc9f5'

CRAWLBASE_CRAWLING_API_URL = "https://api.crawlbase.com?token={0}&url={1}&crawler={2}&callback=true&callback_headers={3}"

РАЗМЕР_ПАКЕТА = 100
DELAY_SECONDS = 1

защиту повторная_операция(операция, max_retries=3, задержка=2):
    для попытка in ассортимент(1, макс_повторений + 1):
        стараться:
            возвращают операция()
        кроме Исключение as e:
            Распечатать(f"- Ошибка при повторной попытке '{пытаться}':\n{е}")

        if попытка < max_retries:
            Распечатать(f"- Повторная попытка {задерживать} секунд...")
            время.сна(задержка)

    повышение Исключение(«Превышено максимальное количество попыток».)

защиту ползать(URL):
    url = url.strip()
    encoded_url = urllib.parse.quote(url, safe="")
    encoded_crawlbase_crawler_name = urllib.parse.quote(CRAWLBASE_CRAWLER_NAME, safe="")
    encoded_callback_headers = urllib.parse.quote(f"МОЙ-ИДЕНТИФИКАТОР:{REQUEST_SECURITY_ID}", безопасно="")

    api_url = CRAWLBASE_CRAWLING_API_URL.формат(CRAWLBASE_TOKEN, закодированный_url, закодированное_имя_базы_сканера_сканирования, закодированные_заголовки_обратных_вызовов)

    стараться:
        защиту выполнить_запрос():
            ответ = запросы.получить(api_url)
            ответ.raise_for_status()
            возвращают ответ

        ответ = повтор_операции(лямбда: выполнить_запрос())
        json_response = json.loads(response.text)
        crawlbase_rid = json_response["избавлять"]

        data_dir = os.path.join(Path.cwd(), "данные")
        Путь(data_dir).mkdir(parents=Правда, существует_ok=Правда)

        rid_dir = os.path.join(data_dir, crawlbase_rid)
        Путь(rid_dir).mkdir(родители=Правда, существует_ok=Правда)

        Распечатать(f"- Запрос на сканирование для '{URL}' был успешно отправлен.")

    кроме Исключение as e:
        Распечатать(f"- Произошла ошибка при обработке '{URL}':\n{е}")

защиту пакетное_сканирование(URL-адреса):
    темы = []

    для URL in URL-адреса:
        t = поток.Thread(target=crawl, args=(url,))
        нити.append(t)
        т.старт()

    для t in темы:
        т.присоединиться()

защиту сканировать_urls(URL-адреса):
    для i in ассортимент(0, только(urls), BATCH_SIZE):
        batched_urls = urls[i:i + BATCH_SIZE]
        Распечатать(пакетные_urls)
        пакетное_сканирование(batched_urls)
        время.сна(DELAY_SECONDS)


if __имя__ == "__основной__":

    URL-адреса = [
        "http://httpbin.org/",
        "https://github.com/crawlbase",
        "http://httpbin.org/ip",
        "http://httpbin.org/html",
    ]
    crawl_urls(urls)

Шаг 4: Запустите свой веб-сайт Crawler.

1
python-ползать.py

Пример вывода:

Скриншот вывода консоли Crawl

Перейдите на HTTP-сервер WebHook консоль терминала, и вы должны увидеть похожий вывод ниже:

Скриншот HTTP-сервера Webhook после сканирования

Этот процесс генерирует data каталог, который включает в себя подкаталог с именем <rid> для каждого запроса на сканирование:

Скриншот выходных данных папки с данными

  1. Команда <rid> файл содержит извлеченные данные.

  2. Команда <rid>.meta.json file содержит связанные метаданные:

Пример:

1
2
3
4
5
6
{
  "избавлять": " ",
  "запрошенный_url": "http://httpbin.org/",
  "исходный_статус": "200",
  "crawlbase_status": "200"
}

Получите полный код на Github.

Crawler Техническое обслуживание и мониторинг

После того, как ваш масштабируемый веб-скрейпер запущен и работает, необходимы надлежащий мониторинг и обслуживание, чтобы поддерживать масштабируемость и эффективность. Вот некоторые вещи, которые следует учитывать:

Управление Crawler трафик

Crawlbase предлагает полный набор API, которые позволяют вам делать следующее:

  1. Приостановить или возобновить работу сканера
  2. Очистить или удалить задания
  3. Проверьте активные задания и размер очереди

Для получения более подробной информации вы можете изучить Crawler Документы API.

Кроме того, если ваш сканер, по-видимому, отстает или неожиданно останавливается, вы можете отслеживать его задержку или разницу во времени с момента добавления самого старого задания в очередь из Crawlerприборная панель. При необходимости вы также можете перезапустить свой сканер прямо с этой страницы.

Инструменты мониторинга

Используйте эти инструменты, чтобы отслеживать ваши Crawler активность и выявлять проблемы до того, как они повлияют на масштаб.

  1. Crawler Главная - Просмотр текущей стоимости, количества успешных и неудачных попыток TCP или JavaScript Crawler.
  2. Живой монитор - Отслеживайте активность в режиме реального времени, включая успешные сканирования, сбои, размер очереди и ожидающие повторные попытки.
  3. Повторить монитор - Просмотр подробного описания повторных запросов.

Примечание: Эти неудачные попытки, показанные на панели управления, представляют внутреннюю логику повтора. Вам не нужно беспокоиться об их обработке, так как система разработана так, чтобы автоматически запрашивать неудачные задания для повтора.

Crawler ограничения

Вот значения по умолчанию, которые следует учитывать при масштабировании:

  • Ограничение скорости push-уведомлений: 30 запросов/секунду
  • Параллелизм: 10 одновременных работ
  • Количество повторов: 110 попыток на запрос
  • Команда объединенный лимит очереди для всех ваших Crawlers — 1 миллион страниц. Если этот предел достигнут, система временно приостанавливает push-запросы и возобновляет работу автоматически, когда очередь очистится.

Имейте в виду, что эти ограничения могут быть скорректированы в соответствии с вашими конкретными требованиями. Просто свяжитесь с Crawlbase Служба поддержки клиентов: запросить обновление.

Масштабируйте свой веб-скрапинг с помощью Crawlbase

Проекты по веб-скрейпингу вышли за рамки написания надежных скриптов и управления прокси. Вам нужна инфраструктура корпоративного уровня, которая одновременно соответствует требованиям законодательства и адаптируется к меняющимся потребностям современного делового мира.

Crawlbase разработан для производительности, надежности и масштабируемости. Благодаря его решениям компании и разработчики, такие как ваша, извлекли действенные идеи для роста.

Зарегистрируйтесь сейчас бесплатно.

Часто задаваемые вопросы (FAQ)

В: Могу ли я создать свой собственный Crawler вебхук?

Да, для масштабирования веб-скрапинга всегда полезно создать веб-хук для вашего Crawler. Мы рекомендуем вам ознакомиться с нашим полным руководством. Как использовать Crawlbase Crawler чтобы узнать как.

В: Могу ли я протестировать Crawler бесплатно?

В настоящее время вам необходимо добавьте ваши платежные реквизиты первым использовал Crawler. Crawlbase не предоставляет бесплатные кредиты по умолчанию при регистрации Crawler, но вы можете обратиться в службу поддержки клиентов, чтобы запросить бесплатную пробную версию.

В: Каковы наилучшие методы обработки динамического контента при веб-скрапинге?

Хотите заняться динамическим контентом в веб-скрапинге? Вот несколько первоклассных практик, которые следует иметь в виду:

  1. API-интерфейс кредитного плеча: Взгляните на сетевую активность, чтобы увидеть, извлекаются ли данные из внутреннего API. Этот метод обычно быстрее и надежнее для скрапинга.

  2. Стратегически ждите: Вместо того чтобы полагаться на жестко заданные тайм-ауты, используйте умные стратегии ожидания, такие как waitForSelector or waitForNetworkIdle чтобы убедиться, что все элементы полностью загружены, прежде чем продолжить.

  3. Используйте API для скрапинга: Такие инструменты, как Crawlbase может облегчить вам жизнь, обрабатывая динамический контент, управляя рендерингом, выполнением JavaScript и даже мерами по борьбе с ботами.

В: Каковы наилучшие практики ротации прокси-серверов при веб-скрапинге?

Итак, если вам интересно узнать о лучших методах ротации прокси-серверов при веб-скрапинге, вот что вам следует учесть:

  1. Используйте резидентные или центральные прокси-серверы с умом: Выберите правильный тип в зависимости от того, какой сайт вы используете. Резидентные прокси сложнее обнаружить, но они стоят дороже.

  2. Автоматизировать вращение: Настройте автоматическую смену IP-адресов после нескольких запросов или через определенное количество секунд, чтобы поддерживать актуальность информации.

  3. Избегайте перегрузки одного IP-адреса: Равномерно распределяйте запросы по разным прокси-серверам, чтобы избежать шаблонов, которые могут вызвать тревогу у систем защиты от ботов.

  4. Мониторинг работоспособности прокси-сервера: Следите за временем отклика, кодами состояния и показателями успешности, чтобы обнаружить и заменить неисправные прокси-серверы.

  5. Используйте управляемое прокси-решение: Услуги, подобные Crawlbase обеспечивают встроенное управление прокси-серверами и их ротацию, поэтому вам не придется заниматься ручной настройкой.

В: Каковы наилучшие методы обработки больших наборов данных, полученных в результате веб-скрапинга?

Когда дело доходит до обработки больших наборов данных из веб-скрапинга, есть несколько лучших практик, которые могут иметь существенное значение. Вот несколько советов, которые следует иметь в виду:

  1. Используйте пагинацию и пакетирование: Вместо того, чтобы скрабить все сразу, разбейте свои задачи на более мелкие части, используя параметры страницы или диапазоны дат. Это поможет избежать перегрузки серверов или проблем с памятью.

  2. Храните данные постепенно: Потоковая передача ваших скопированных данных непосредственно в базы данных или облачное хранилище по мере их поступления. Таким образом, вы можете избежать перегрузки памяти и сохранить все организованным.

  3. Нормализуйте и очистите данные на ранней стадии: Уделите время очистке, дедупликации и структурированию данных во время скрапинга. Это облегчит нагрузку на любую обработку, которую вам нужно будет выполнить позже.

  4. Внедрение систем повторных попыток и ведения журнала: Отслеживайте любые URL, которые не удается очистить, и создайте систему для повторной попытки позже. Регистрация статистики очистки также может помочь вам отслеживать прогресс и выявлять любые проблемы.

  5. Используйте масштабируемую инфраструктуру: Подумайте об использовании асинхронного скрапинга, очередей заданий или бессерверных функций для обработки более крупных задач. Такие инструменты, как Crawlbase может помочь вам масштабировать извлечение данных без хлопот по управлению внутренними ресурсами.