Design a web crawler

Design a web crawler

Step 1: Outline use cases and constraints

Use cases

We'll scope the problem to handle only the following use cases

  • Service crawls a list of urls:

    • Generates reverse index of words to pages containing the search terms

    • Generates titles and snippets for pages

      • Title and snippets are static, they do not change based on search query

  • User inputs a search term and sees a list of relevant pages with titles and snippets the crawler generated

    • Only sketch high level components and interactions for this use case, no need to go into depth

  • Service has high availability

Out of scope

  • Search analytics

  • Personalized search results

  • Page rank

Constraints and assumptions

State assumptions

  • Traffic is not evenly distributed

    • Some searches are very popular, while others are only executed once

      有 hot entity issue，有的 search traffic 会非常高

  • Support only anonymous users

  • Generating search results should be fast

    对 efficiency 有要求

  • The web crawler should not get stuck in an infinite loop

    • We get stuck in an infinite loop if the graph contains a cycle

  • 1 billion links to crawl

    • Pages need to be crawled regularly to ensure freshness

    • Average refresh rate of about once per week, more frequent for popular sites

      • 4 billion links crawled each month

    • Average stored size per web page: 500 KB

      • For simplicity, count changes the same as new pages

  • 100 billion searches per month

Exercise the use of more traditional systems - don't use existing systems such as solr or nutch.

Calculate usage

  • 2 PB of stored page content per month

    • 500KB∗4billionlinks500 KB * 4 billion links crawled per month

    • 72 PB = 2PB∗12∗3years2 PB * 12 * 3 years of stored page content in 3 years

  • 1,600 write requests per second

  • 40,000 search requests per second

Handy conversion guide:

  • 2.5 million seconds per month

  • 1 request per second = 2.5 million requests per month

  • 40 requests per second = 100 million requests per month

  • 400 requests per second = 1 billion requests per month

Step 2: Create a high level designs

Step 3: Design core components

Use case: Service crawls a list of urls

We'll assume we have an initial list of links_to_crawl ranked initially based on overall site popularity. If this is not a reasonable assumption, we can seed the crawler with popular sites that link to outside content such as Yahoo, DMOZ, etc.

We'll use a table crawled_links to store processed links and their page signatures.

We could store links_to_crawl and crawled_links in a key-value NoSQL Database. For the ranked links in links_to_crawl, we could use Redis with sorted sets to maintain a ranking of page links. We should discuss the use cases and tradeoffs between choosing SQL or NoSQL.

The Crawler Service processes each page link by doing the following in a loop:

Takes the top ranked page link to crawl:
    Checks `crawled_links` in the NoSQL Database for an entry with a similar page signature:
        If (we have a similar page, reduces the priority of the page link) {
            * This prevents us from getting into a cycle
            * Continue
        } else, crawls the link {
            * Adds a job to the Reverse Index Service queue to generate a reverse index
            * Adds a job to the Document Service queue to generate a static title and snippet
            * Generates the page signature
            * Removes the link from links_to_crawl in the NoSQL Database
            * Inserts the page link and signature to crawled_links in the NoSQL Database
        }

  • PagesDataStore is an abstraction within the Crawler Service that uses the NoSQL Database:

class PagesDataStore(object):

    def __init__(self, db);
        self.db = db
        ...

    def add_link_to_crawl(self, url):
        """Add the given link to `links_to_crawl`."""
        ...

    def remove_link_to_crawl(self, url):
        """Remove the given link from `links_to_crawl`."""
        ...

    def reduce_priority_link_to_crawl(self, url)
        """Reduce the priority of a link in `links_to_crawl` to avoid cycles."""
        ...

    def extract_max_priority_page(self):
        """Return the highest priority link in `links_to_crawl`."""
        ...

    def insert_crawled_link(self, url, signature):
        """Add the given link to `crawled_links`."""
        ...

    def crawled_similar(self, signature):
        """Determine if we've already crawled a page matching the given signature"""
        ...

  • Page is an abstraction within the Crawler Service that encapsulates a page, its contents, child urls, and signature:

class Page(object):

    def __init__(self, url, contents, child_urls, signature):
        self.url = url
        self.contents = contents
        self.child_urls = child_urls
        self.signature = signature

  • Crawler is the main class within Crawler Service, composed of Page and PagesDataStore.

class Crawler(object):

    def __init__(self, data_store, reverse_index_queue, doc_index_queue):
        self.data_store = data_store
        self.reverse_index_queue = reverse_index_queue
        self.doc_index_queue = doc_index_queue

    def create_signature(self, page):
        """Create signature based on url and contents."""
        ...

    def crawl_page(self, page):
        for url in page.child_urls:
            self.data_store.add_link_to_crawl(url)
        page.signature = self.create_signature(page)
        self.data_store.remove_link_to_crawl(page.url)
        self.data_store.insert_crawled_link(page.url, page.signature)

    def crawl(self):
        while True:
            page = self.data_store.extract_max_priority_page()
            if page is None:
                break
            if self.data_store.crawled_similar(page.signature):
                self.data_store.reduce_priority_link_to_crawl(page.url)
            else:
                self.crawl_page(page)

Handling duplicates

We need to be careful the web crawler doesn't get stuck in an infinite loop, which happens when the graph contains a cycle.

We'll want to remove duplicate urls:

  • For smaller lists we could use something like sort | unique

  • With 1 billion links to crawl, we could use MapReduce to output only entries that have a frequency of 1

class RemoveDuplicateUrls(MRJob):

    def mapper(self, _, line):
        yield line, 1

    def reducer(self, key, values):
        total = sum(values)
        if total == 1:
            yield key, total

Detecting duplicate content is more complex. We could generate a signature based on the contents of the page and compare those two signatures for similarity. Some potential algorithms are Jaccard index and cosine similarity.

Determining when to update the crawl results

Pages need to be crawled regularly to ensure freshness. Crawl results could have a timestamp field that indicates the last time a page was crawled. After a default time period, say one week, all pages should be refreshed. Frequently updated or more popular sites could be refreshed in shorter intervals.

Although we won't dive into details on analytics, we could do some data mining to determine the mean time before a particular page is updated, and use that statistic to determine how often to re-crawl the page.

We might also choose to support a Robots.txt file that gives webmasters control of crawl frequency.

Use case: User inputs a search term and sees a list of relevant pages with titles and snippets

  • The Client sends a request to the Web Server, running as a reverse proxy

  • The Web Server forwards the request to the Query API server

  • The Query API server does the following:

    • Parses the query

      • Removes markup

      • Breaks up the text into terms

      • Fixes typos

      • Normalizes capitalization

      • Converts the query to use boolean operations

    • Uses the Reverse Index Service to find documents matching the query

      • The Reverse Index Service ranks the matching results and returns the top ones

    • Uses the Document Service to return titles and snippets

We'll use a public REST API:

$ curl https://search.com/api/v1/search?query=hello+world

Response:

{
    "title": "foo's title",
    "snippet": "foo's snippet",
    "link": "https://foo.com",
},
{
    "title": "bar's title",
    "snippet": "bar's snippet",
    "link": "https://bar.com",
},
{
    "title": "baz's title",
    "snippet": "baz's snippet",
    "link": "https://baz.com",
},

For internal communications, we could use Remote Procedure Calls.

Step 4: Scale the design

State you would 1) Benchmark/Load Test, 2) Profile for bottlenecks 3) address bottlenecks while evaluating alternatives and trade-offs, and 4) repeat. See Design a system that scales to millions of users on AWS as a sample on how to iteratively scale the initial design.

It's important to discuss what bottlenecks you might encounter with the initial design and how you might address each of them. For example, what issues are addressed by adding a Load Balancer with multiple Web Servers? CDN? Master-Slave Replicas? What are the alternatives and Trade-Offs for each?

We'll introduce some components to complete the design and to address scalability issues. Internal load balancers are not shown to reduce clutter.

To avoid repeating discussions, refer to the following system design topics for main talking points, tradeoffs, and alternatives:

  • DNS

  • Load balancer

  • Horizontal scaling

  • Web server (reverse proxy)

  • API server (application layer)

  • Cache

  • NoSQL

  • Consistency patterns

  • Availability patterns

Some searches are very popular, while others are only executed once. Popular queries can be served from a Memory Cache such as Redis or Memcached to reduce response times and to avoid overloading the Reverse Index Service and Document Service. The Memory Cache is also useful for handling the unevenly distributed traffic and traffic spikes. Reading 1 MB sequentially from memory takes about 250 microseconds, while reading from SSD takes 4x and from disk takes 80x longer.

Below are a few other optimizations to the Crawling Service:

  • To handle the data size and request load, the Reverse Index Service and Document Service will likely need to make heavy use sharding and federation.

  • DNS lookup can be a bottleneck, the Crawler Service can keep its own DNS lookup that is refreshed periodically

  • The Crawler Service can improve performance and reduce memory usage by keeping many open connections at a time, referred to as connection pooling

    • Switching to UDP could also boost performance

  • Web crawling is bandwidth intensive, ensure there is enough bandwidth to sustain high throughput

Additional talking points

SQL scaling patterns

  • Read replicas

  • Federation

  • Sharding

  • Denormalization

  • SQL Tuning

NoSQL

  • Key-value store

  • Document store

  • Wide column store

  • Graph database

  • SQL vs NoSQL

Caching

Where to cache

  • Client caching

  • CDN caching

  • Web server caching

  • Database caching

  • Application caching

    What to cache

  • Caching at the database query level

  • Caching at the object level

    When to update the cache

  • Cache-aside

  • Write-through

  • Write-behind (write-back)

  • Refresh ahead

Asynchronism and microservices

  • Message queues

  • Task queues

  • Back pressure

  • Microservices

Communications

  • Discuss tradeoffs:

    • External communication with clients - HTTP APIs following REST

    • Internal communications - RPC

  • Service discovery

Security

Refer to the security section.

Latency numbers

See Latency numbers every programmer should know.

Ongoing

  • Continue benchmarking and monitoring your system to address bottlenecks as they come up

  • Scaling is an iterative process

PreviousDesigning a Web Crawler/Archive (scott)NextDesigning Dropbox

Last updated