Системный дизайн веб-краулера: frontier, robots.txt, дедупликация и масштабирование
Как спроектировать поисковый краулер на system design интервью: оценка нагрузки, URL frontier с приоритетами и вежливостью, robots.txt, дедупликация URL и контента, шардирование по хостам.
Коротко
| Вопрос | Решение в этом разборе |
|---|---|
| Нагрузка | 1 млрд страниц в месяц: около 400 страниц в секунду, в пике около 800 |
| Трафик и хранилище | около 300 Мбит/с входящего, около 20 ТБ сжатого HTML в месяц |
| Сердце системы | URL frontier: очереди приоритетов и отдельные очереди на каждый хост |
| Вежливость | не больше одного запроса к хосту за раз, пауза между запросами, robots.txt |
| Дедупликация URL | нормализация + множество отпечатков (или фильтр Блума) |
| Дедупликация HTML | точный хеш для копий, SimHash для почти-копий |
| Масштабирование | шардирование по хешу хоста: вся вежливость к одному сайту живёт на одном узле |
| Главный компромисс | охват и свежесть против нагрузки на чужие сайты |
Краулер на собеседовании кажется простым: «берём URL из очереди, качаем, достаём ссылки, кладём обратно». Это обход графа в ширину, его пишут за десять строк. Интервьюер ждёт другого: как не положить чужой сайт, как не утонуть в бесконечных календарях и как не скачать одну и ту же страницу сто раз под разными адресами.
Общий план system design секции описан в статье про подходы к проектированию систем. Здесь он применён к краулеру от требований до узких мест.
Как распределить время
| Этап | Минуты | Что должно остаться на доске |
|---|---|---|
| Требования | 5 | для чего краулер, объём, свежесть |
| Оценка нагрузки | 5 | страниц в секунду, трафик, хранилище |
| Общая схема | 5 | цикл: frontier → загрузчик → парсер → frontier |
| Frontier и вежливость | 10 | очереди приоритетов и очереди хостов |
| Дедупликация | 8 | URL и контент отдельно |
| Масштабирование и надёжность | 10 | шардирование, DNS, ловушки, повторный обход |
| Вопросы вглубь | 2–5 | JavaScript, свежесть, приоритеты |
Шаг 1. Требования
Слово «краулер» покрывает очень разные системы. Сначала выясните, для чего он.
| Вопрос | Ответ интервьюера | Что это меняет |
|---|---|---|
| Зачем обходим? | для поискового индекса | нужен HTML и ссылки, картинки и видео не качаем |
| Сколько страниц? | 1 млрд в месяц | одна машина не справится, нужен кластер |
| Только HTML? | да | фильтр по Content-Type и расширениям |
| Нужно ли исполнять JavaScript? | нет, на первом этапе | обычный HTTP-клиент без браузера |
| Как часто обновлять страницы? | новости — часто, остальное — реже | планировщик повторного обхода с приоритетами |
| Хранить скачанное? | да, 5 лет | хранилище объектов, сжатие |
| Дубли нужны? | нет | дедупликация URL и контента |
Нефункциональные требования предложите сами:
- Вежливость. Краулер не должен выглядеть как DDoS для маленького сайта. Это требование важнее скорости, и его стоит произнести первым.
- Устойчивость к мусору. Интернет полон бесконечных страниц, битого HTML и ловушек. Краулер не должен на них застревать.
- Масштабируемость. Добавили машины — выросла скорость, без переделки архитектуры.
- Восстанавливаемость. Обход идёт неделями. Падение узла не должно начинать всё заново.
Не делаем: рендеринг JavaScript, построение индекса и ранжирование. Индекс — отдельная система, которая читает то, что скачал краулер.
Шаг 2. Оценка нагрузки
Допущения, которые предлагаете вы:
- 1 млрд страниц в месяц.
- Средний размер HTML примем 100 КБ. Это допущение с запасом, медианная страница легче. Скажите об этом вслух.
- Пик в 2 раза выше среднего.
- HTML хорошо сжимается, примем коэффициент 5.
| Параметр | Расчёт | Результат |
|---|---|---|
| Страниц в секунду | 1 млрд / (30 × 86 400) | около 400 |
| В пике | 400 × 2 | около 800 |
| Входящий трафик | 400 × 100 КБ | около 40 МБ/с, ≈ 300 Мбит/с |
| Сырой HTML в месяц | 1 млрд × 100 КБ | 100 ТБ |
| Сжатый HTML в месяц | 100 ТБ / 5 | 20 ТБ |
| За 5 лет | 20 ТБ × 60 | около 1,2 ПБ |
| Одновременных загрузок | 400 стр/с × 1–3 с на страницу | от 400 до 1200 соединений |
Выводы:
- Узкое место — не CPU. 400 страниц в секунду по одной машине не раскладываются из-за сети и ожидания ответа: средний запрос с DNS, TLS и медленным сервером занимает секунды. Нужны сотни одновременных соединений. Асинхронный клиент держит тысячи на одной машине, так что загрузчиков нужно несколько, и в основном ради отказоустойчивости.
- Хранилище — петабайты. Только хранилище объектов (S3 и аналоги), никакой реляционной базы для тел страниц.
- DNS станет проблемой. 400 разрешений имён в секунду без кэша — это нагрузка на резолвер и лишние сотни миллисекунд на каждую страницу.
Шаг 3. Общая схема
┌──────────────┐
seed ───►│ URL frontier │◄──────────────────────────────┐
└──────┬───────┘ │
│ URL, к которому уже можно │
▼ │
┌──────────────┐ ┌─────────────┐ │
│ Загрузчики │──►│ DNS-кэш, │ │
│ (fetchers) │ │ robots-кэш │ │
└──────┬───────┘ └─────────────┘ │
│ HTML │
▼ │
┌──────────────┐ ┌──────────────────┐ │
│ Дедупликация │──►│ Хранилище HTML │ │
│ контента │ │ (object storage) │ │
└──────┬───────┘ └──────────────────┘ │
▼ │
┌──────────────┐ ┌──────────────┐ ┌────────┴─────┐
│ Парсер, │──►│ Нормализация │──►│ «Видели URL?»│
│ извлечь ссылки│ │ и фильтры │ │ (URL seen) │
└──────────────┘ └──────────────┘ └──────────────┘
Цикл такой:
- Frontier отдаёт URL, к хосту которого сейчас можно обратиться.
- Загрузчик берёт IP из DNS-кэша, проверяет robots.txt, качает страницу.
- Если такой контент уже был, страницу отбрасываем. Иначе сохраняем HTML.
- Парсер достаёт ссылки, нормализует их и отбрасывает лишнее.
- Новые URL, которых ещё не видели, уходят во frontier.
Между компонентами стоят очереди: парсер медленнее загрузчика, и буфер сглаживает разницу. Как устроены такие очереди и что с повторной доставкой, разобрано в статье про очереди сообщений.
Шаг 4. URL frontier
Frontier — главный компонент, на нём и проверяют кандидата. Наивный вариант — одна FIFO-очередь, то есть обход в ширину. У неё две проблемы:
- Невежливость. Ссылки со страницы чаще всего ведут на тот же сайт. Очередь заполняется URL одного хоста, и сотня загрузчиков одновременно бьёт в один сервер.
- Нет приоритетов. Главная страница крупного новостного сайта и сотая страница архива форума стоят в одной очереди.
Классическое решение пришло из краулера Mercator: frontier делится на две части.
Передние очереди (front queues) отвечают за приоритет. Есть, например, 10 очередей по уровням важности. Приоритизатор раскладывает URL по ним с учётом PageRank домена, частоты изменений страницы, глубины от главной. Выборка идёт из очередей со смещением в пользу важных, но и низкие иногда получают ход, иначе они будут голодать вечно.
Задние очереди (back queues) отвечают за вежливость. Одна очередь — один хост. Рядом лежит куча, где для каждого хоста записано, когда к нему можно обратиться в следующий раз. Загрузчик берёт хост с самым ранним моментом, качает один URL и возвращает хост в кучу с моментом «сейчас + пауза».
Вот ядро вежливой части на Python. Приоритеты опущены, чтобы был виден сам механизм:
import heapq from collections import deque from urllib.parse import urlsplit class Frontier: """Очереди по хостам + куча «когда к хосту снова можно».""" def __init__(self, delay: float = 1.0): self.delay = delay # пауза между запросами к одному хосту, с self.queues = {} # host -> deque URL self.ready = [] # куча (момент, host) self.seen = set() # уже добавленные URL self.last = {} # host -> время последнего запроса def add(self, url: str, now: float) -> None: if url in self.seen: return self.seen.add(url) host = urlsplit(url).hostname if host not in self.queues: self.queues[host] = deque() allowed = self.last.get(host, -self.delay) + self.delay heapq.heappush(self.ready, (max(now, allowed), host)) self.queues[host].append(url) def next(self, now: float): """URL, который можно качать сейчас, или None.""" if not self.ready or self.ready[0][0] > now: return None _, host = heapq.heappop(self.ready) url = self.queues[host].popleft() self.last[host] = now if self.queues[host]: heapq.heappush(self.ready, (now + self.delay, host)) else: del self.queues[host] # хост опустел: при новом URL вернётся в кучу return url f = Frontier(delay=1.0) for u in ["https://a.ru/1", "https://a.ru/2", "https://a.ru/3", "https://b.ru/1", "https://a.ru/1"]: f.add(u, now=0) t = 0.0 while f.queues: url = f.next(t) if url: print(f"t={t:.1f} {url}") if url == "https://b.ru/1": f.add("https://b.ru/2", now=t) # нашли ссылку, хост b.ru уже опустел else: t += 0.5 # t=0.0 https://a.ru/1 # t=0.0 https://b.ru/1 # t=1.0 https://a.ru/2 # t=1.0 https://b.ru/2 # t=2.0 https://a.ru/3
Обратите внимание на словарь last. Без него хост, у которого кончились URL, при появлении новой ссылки сразу вернулся бы в кучу с моментом «сейчас», и b.ru/2 скачался бы в ту же секунду, что и b.ru/1. Такой баг легко пропустить: вежливость нарушается только на коротких очередях.
Почему куча, а не перебор хостов: хостов миллионы, а нужен один — с минимальным моментом. Куча даёт его за . Подробнее о ней — в статье про очередь с приоритетом.
Размер frontier
Со страницы уходит в среднем несколько десятков ссылок, и даже после дедупликации frontier растёт быстрее, чем его разбирают. Миллиард URL по 100 байт — это 100 ГБ. В память не влезает, поэтому очереди живут на диске: в памяти держат голову и хвост каждой очереди, а середину пишут в файлы или в базу. Так был устроен и Mercator.
Вывод для интервью: frontier — это не «очередь в Redis», а персистентная структура, которую шардируют и сохраняют чекпоинтами.
Шаг 5. Вежливость и robots.txt
Вежливость складывается из нескольких правил:
- Один запрос к хосту за раз. Это даёт очередь на хост из предыдущего шага.
- Пауза между запросами. Хорошая эвристика: ждать в несколько раз дольше, чем отвечал сервер. Сайт отвечает медленно — значит, ему тяжело, и краулер замедляется сам.
- Реакция на ошибки. Ответы 429 и 503 означают «отстань», заголовок
Retry-Afterнадо уважать. Серия 5xx — повод отложить весь хост. - Честный User-Agent с адресом страницы, где написано, кто вы и как с вами связаться.
- robots.txt.
Как работает robots.txt
С 2022 года это стандарт RFC 9309. Файл лежит в корне хоста и состоит из групп: User-agent и набор правил Allow/Disallow. Важные детали:
- Правила действуют на хост целиком, включая схему и порт:
https://shop.ruиhttps://m.shop.ru— разные файлы. - Краулер выбирает группу со своим именем. Если её нет — группу
*. Группы не складываются: если для вашего бота есть своя группа, правила из*к нему не относятся. - Если подходят несколько правил, побеждает самое длинное совпадение пути.
Crawl-delayв стандарт не вошёл. Google его игнорирует, другие краулеры учитывают.
Отдельно стоит продумать ошибки при загрузке самого файла. Поведение Google хороший ориентир: 4xx (кроме 429) считается «файла нет, ограничений нет», а 5xx и сетевые ошибки — «нельзя ничего», пока файл не удастся получить. Кэшируют robots.txt обычно до суток, а обрабатывают только первые 500 КиБ.
В Python парсер есть в стандартной библиотеке:
from urllib.robotparser import RobotFileParser robots_txt = """ User-agent: * Disallow: /admin/ Disallow: /search Crawl-delay: 2 User-agent: SprintBot Disallow: /private/ """ rp = RobotFileParser() rp.parse(robots_txt.splitlines()) print(rp.can_fetch("SprintBot", "https://shop.ru/admin/users")) # True: для SprintBot своя группа print(rp.can_fetch("SprintBot", "https://shop.ru/private/a")) # False print(rp.can_fetch("OtherBot", "https://shop.ru/search?q=tv")) # False print(rp.crawl_delay("OtherBot")) # 2
Первая строка — та самая ловушка с группами. /admin/ закрыт для всех, кроме SprintBot, потому что у него своя группа без этого правила. Учтите, что поведение urllib.robotparser менялось между версиями: долгое время он применял первое подходящее правило в порядке записи и не понимал шаблонов * и $, а в свежих выпусках выбирает самое длинное совпадение. Если краулер должен вести себя одинаково везде, проверьте свою версию на спорных случаях или возьмите библиотеку, которая явно следует RFC.
Где хранить разобранные правила: в кэше рядом с загрузчиком, ключ — хост, время жизни — сутки. Миллионы хостов по несколько килобайт помещаются в память кластера, а запрос robots.txt перед каждой страницей удвоил бы нагрузку на сайты.
Шаг 6. Дедупликация URL
Одна и та же страница бывает доступна по десяткам адресов: другой регистр хоста, порт по умолчанию, якорь #top, переставленные параметры, метки utm_*. Поэтому сначала URL приводят к каноническому виду, а уже потом спрашивают «видели ли мы его».
from urllib.parse import urlsplit, urlunsplit, parse_qsl, urlencode, urljoin TRACKING = {"utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content", "gclid", "fbclid"} DEFAULT_PORTS = {"http": 80, "https": 443} def normalize(url: str, base: str | None = None) -> str | None: if base: url = urljoin(base, url) parts = urlsplit(url.strip()) scheme = parts.scheme.lower() if scheme not in DEFAULT_PORTS: return None # mailto:, javascript:, ftp: и прочее не обходим host = (parts.hostname or "").lower().rstrip(".") if not host: return None netloc = host if parts.port and parts.port != DEFAULT_PORTS[scheme]: netloc = f"{host}:{parts.port}" path = parts.path or "/" query = urlencode( sorted((k, v) for k, v in parse_qsl(parts.query, keep_blank_values=True) if k.lower() not in TRACKING) ) return urlunsplit((scheme, netloc, path, query, "")) # фрагмент #... отбрасываем print(normalize("HTTPS://Example.COM:443/a?b=2&a=1&utm_source=tg#top")) # https://example.com/a?a=1&b=2 print(normalize("../news?id=7", base="https://example.com/blog/post")) # https://example.com/news?id=7 print(normalize("mailto:me@example.com")) # None
Сортировка параметров — тот же приём, что в задаче про группировку анаграмм: разные записи одного объекта приводятся к одному ключу. Регистр пути трогать нельзя: на большинстве серверов /About и /about — разные страницы.
Нормализация не ловит всё. Сайт может отдавать одну страницу по /item/42 и /item/42/slug-tovara. Здесь помогает <link rel="canonical"> в HTML и дедупликация по контенту из следующего шага.
Множество «видели URL»
Теперь нужно множество на миллиарды элементов. Варианты:
| Вариант | Память на 10 млрд URL | Ошибки |
|---|---|---|
| Сами строки URL | около 1 ТБ | нет |
| 64-битные отпечатки (хеш) | 80 ГБ | ожидается около 3 коллизий на всё множество |
| Фильтр Блума, 1% ложных | около 12 ГБ | 1% новых URL ошибочно считаем виденными |
Цифры для 64-битных отпечатков — парадокс дней рождения: при . Три потерянные страницы из десяти миллиардов — приемлемо. Для фильтра Блума нужно бита на элемент при . Ошибка у него односторонняя: новый URL иногда пропустим, но дважды не скачаем. Как устроен фильтр, разобрано в отдельной статье.
Типичный ответ на интервью: отпечатки в шардированном key-value хранилище (на диске, с кэшем в памяти), а фильтр Блума перед ним, чтобы большинство проверок вообще не ходило на диск. По сути это хеш-множество, как в задаче «есть ли дубликаты в массиве», только размазанное по кластеру.
Шаг 7. Дедупликация контента
Заметная доля страниц в вебе — копии и почти-копии: зеркала, версии для печати, одна статья на десятке агрегаторов, карточки товара, которые отличаются только счётчиком просмотров. Хранить и индексировать их незачем.
Точные копии ловит хеш от тела страницы. SHA-256 или любой 64–128-битный хеш, дальше то же множество, что и для URL.
Почти-копии точный хеш не видит: изменился один символ — хеш другой. Для них нужен хеш, который у похожих текстов даёт похожие значения. Классика — SimHash. В 2007 году инженеры Google описали, как с его помощью искали почти-дубликаты на 8 млрд страниц: 64-битные отпечатки и порог в 3 различающихся бита.
Алгоритм:
- Разбить текст на шинглы — перекрывающиеся тройки слов.
- Для каждого шингла посчитать 64-битный хеш.
- Завести 64 счётчика. Для каждого бита каждого хеша: бит равен 1 — счётчик плюс один, 0 — минус один.
- Итоговый бит равен 1, если счётчик положительный.
Мелкая правка меняет несколько шинглов из сотен, и итоговые счётчики почти не сдвигаются. Сравнивают отпечатки по расстоянию Хэмминга — числу различающихся бит.
import hashlib import re def shingles(text: str, k: int = 3): words = re.findall(r"\w+", text.lower()) return {" ".join(words[i : i + k]) for i in range(len(words) - k + 1)} def simhash(text: str, bits: int = 64) -> int: weights = [0] * bits for sh in shingles(text): h = int.from_bytes(hashlib.blake2b(sh.encode(), digest_size=8).digest(), "big") for i in range(bits): weights[i] += 1 if h >> i & 1 else -1 return sum(1 << i for i in range(bits) if weights[i] > 0) def distance(a: int, b: int) -> int: return (a ^ b).bit_count() base = ( "Ноутбук Lenovo ThinkPad с процессором Intel Core i7, 16 ГБ памяти и SSD на 512 ГБ. " "Экран 14 дюймов, вес 1,2 кг, автономность до 12 часов. Доставка по всей России, " "гарантия производителя два года, возврат в течение 14 дней. В комплекте зарядное " "устройство и документация. Подходит для работы, учёбы и поездок." ) page_a = base + " Обновлено в 12:03." page_b = base + " Обновлено в 12:07." # та же страница, другое время в подвале other = ( "Рецепт борща: свёкла, капуста, картофель, морковь и лук. Варите бульон два часа, " "добавьте овощи, в конце положите чеснок и зелень. Подавайте со сметаной." ) h0, h1, h2 = simhash(page_a), simhash(page_b), simhash(other) print(distance(h0, h1), distance(h0, h2)) # 4 34
У почти-копий расстояние 4 из 64, у разных текстов — около 32, как у случайных чисел. Наш текст короткий, всего полсотни слов, поэтому три изменённых шингла сдвинули 4 бита. На полноценных страницах из сотен слов такая же правка двигает меньше, и порог 3 работает.
int.bit_count() есть с Python 3.10. В более старых версиях считайте bin(x).count("1").
Как искать похожие отпечатки быстро. Сравнивать новый отпечаток с миллиардами старых нельзя. Трюк: если два 64-битных числа различаются не больше чем в 3 битах, то при разбиении на 4 блока по 16 бит хотя бы один блок совпадёт целиком. Заводим 4 таблицы, каждая индексирована по своему блоку, и сравниваем полностью только кандидатов, у которых совпал блок. Это частный случай locality-sensitive hashing.
Перед хешированием вырезают шаблон сайта: меню, подвал, рекламные блоки. Иначе все страницы одного сайта будут казаться похожими друг на друга.
Шаг 8. Масштабирование
Шардирование по хосту
Один узел frontier не справится, значит, его надо делить. Ключевое решение — делить по хешу хоста, а не URL. Тогда все URL одного сайта попадают на один узел, и вежливость остаётся локальной: очередь хоста, момент следующего запроса и кэш robots.txt лежат в одном месте, координация между узлами не нужна.
Парсер на любом узле, найдя ссылку на чужой хост, отправляет её узлу-владельцу. Ссылки копят и отправляют пачками: по одной это был бы шторм мелких сообщений. При добавлении узлов используют консистентное хеширование, чтобы переехала только часть хостов.
Множество «видели URL» удобно шардировать так же, по хосту. Тогда проверка «видели ли» тоже локальна для узла.
Проблема — огромные хосты. У Википедии или крупного маркетплейса миллионы страниц, и их узел перегружен. Но вежливость всё равно не даёт качать один хост быстрее заданного темпа, поэтому упирается это в размер очереди на диске, а не в CPU. Для самых крупных хостов договариваются о повышенном лимите или выделяют отдельные узлы.
DNS
Стандартный резолвер синхронный и медленный, а 400 разрешений в секунду — заметная нагрузка. Решения:
- Свой кэш DNS на каждом узле с уважением TTL.
- Асинхронный резолвер, чтобы ожидание DNS не блокировало загрузчик.
- Предразрешение: когда хост попадает во frontier, его IP можно запросить заранее.
Есть ещё одна деталь. Вежливость считают и по IP: на одном сервере виртуального хостинга живут тысячи сайтов, и «по запросу на хост» превращается в тысячу запросов в секунду к одной машине.
Надёжность
- Чекпоинты frontier. Раз в несколько минут состояние очередей сохраняется. После падения узел поднимается с последнего чекпоинта и дообходит потерянный хвост.
- Повторы. Загрузка, которая упала по таймауту, возвращается в очередь хоста с отсрочкой. Число попыток ограничено.
- Идемпотентность записи. Страницу могли скачать дважды из-за повтора. Ключ в хранилище — отпечаток URL, повторная запись просто перезапишет то же самое. Подробнее о приёме — в статье про идемпотентность.
Хранение
Сжатый HTML пишут в хранилище объектов большими файлами, а не по файлу на страницу: миллиард мелких объектов в месяц дорог и в запросах, и в метаданных. Распространённый формат — WARC, его использует, например, Common Crawl. Метаданные (URL, время загрузки, код ответа, отпечатки, ссылка на смещение в WARC-файле) лежат в отдельной таблице, по которой планируют повторный обход.
Шаг 9. Ловушки и повторный обход
Ловушки для краулера
Некоторые сайты генерируют бесконечное число страниц. Иногда случайно: календарь со ссылкой «следующий месяц» до 3000 года, фильтры каталога, которые комбинируются в миллионы вариантов, идентификаторы сессий в URL. Иногда намеренно — чтобы ловить ботов.
Защита — лимиты и эвристики, а не одно умное правило:
- Максимальная длина URL и глубина пути.
- Лимит страниц на хост за один проход обхода.
- Повторяющиеся сегменты пути:
/a/b/a/b/a/b/почти всегда ловушка. - Слишком много параметров в запросе.
- Резкий рост новых URL на хосте при низкой доле новых отпечатков контента: страниц много, а текст один и тот же.
Свежесть
Обход — это не один проход, а цикл. Страницы меняются с разной скоростью: главная новостного сайта — каждые минуты, страница с документацией — раз в год. Планировщик хранит для каждого URL историю: менялась ли страница при последних визитах. Если менялась — интервал до следующего визита уменьшается, если нет — растёт. Это тот же приоритет в передних очередях frontier.
Экономит трафик условный запрос: If-Modified-Since или If-None-Match с сохранённым ETag. Если страница не менялась, сервер отвечает 304 Not Modified без тела.
Вопросы вглубь
- Сайты на JavaScript. Отдельный пул рендеринга с headless-браузером. Он в десятки раз дороже обычной загрузки, поэтому туда отправляют только страницы, где в HTML почти нет текста, но много скриптов.
- Как обходить быстрее, не нарушая вежливость? Параллелизм по хостам, а не по страницам одного хоста. Чем больше разных хостов во frontier, тем полнее загружены загрузчики.
- Приоритет новых страниц. Источники свежих ссылок: sitemap.xml, RSS, сообщения от владельцев сайтов. Их кладут в верхние передние очереди.
- Как сделать краулер сфокусированным, например только на сайты о программировании? Классификатор оценивает релевантность страницы и даёт ссылкам с релевантных страниц приоритет повыше.
- Защита от DDoS-обвинений. Глобальный лимит на исходящий трафик к одной автономной системе и быстрый способ исключить сайт по жалобе. Схема ограничения похожа на rate limiter, только применённый к себе.
Как держаться на таких продолжениях, описано в статье про вопросы вглубь.
Типичные ошибки
- Одна FIFO-очередь. Это обход в ширину, и он бьёт в один сайт сотней потоков.
- Шардирование по URL вместо хоста. Вежливость тогда требует распределённой координации между узлами.
- robots.txt на каждый запрос. Удваивает нагрузку на сайт. Файл кэшируют.
- Дедупликация только по URL. Миллионы зеркал и версий для печати попадут в индекс.
- Точный хеш для почти-копий. Изменился счётчик просмотров — хеш другой.
- Frontier в памяти. Миллиарды URL не помещаются, а падение узла стирает недели работы.
- Нет лимитов на хост. Первый же бесконечный календарь съедает краулер.
- Забыть про DNS. Синхронный резолвер становится узким местом раньше сети.
Что запомнить
- Краулер — это обход графа, где главная сложность не в обходе, а в вежливости, мусоре и масштабе.
- Frontier делится на передние очереди (приоритет) и задние очереди по хостам (вежливость). Куча по моменту «когда можно» выбирает следующий хост за .
- robots.txt кэшируется на сутки, группы не складываются, 5xx при его загрузке означает «пока нельзя ничего».
- URL нормализуют до проверки на дубль. Множество виденных — отпечатки на диске плюс фильтр Блума перед ними.
- Контент дедуплицируют дважды: точным хешем и SimHash с порогом по расстоянию Хэмминга.
- Шардируют по хешу хоста: тогда вся вежливость к сайту живёт на одном узле.