Який найшвидший спосіб надіслати 100 000 HTTP-запитів у Python?

Я відкриваю файл із 100 000 URL-адресами. Мені потрібно надіслати HTTP-запит до кожної URL-адреси та роздрукувати код статусу. Я використовую Python 2.6, і поки що розглянув безліч заплутаних способів, якими Python реалізує потоки / паралельність. Я навіть переглянув бібліотеку узгодження python , але не можу зрозуміти, як правильно написати цю програму. Хтось стикався з подібною проблемою? Я думаю, що, як правило, мені потрібно знати, як виконувати тисячі завдань на Python якомога швидше - я вважаю, що це означає "одночасно".

Рішення без скручування:

from urlparse import urlparse
from threading import Thread
import httplib, sys
from Queue import Queue

concurrent = 200

def doWork():
    while True:
        url = q.get()
        status, url = getStatus(url)
        doSomethingWithResult(status, url)
        q.task_done()

def getStatus(ourl):
    try:
        url = urlparse(ourl)
        conn = httplib.HTTPConnection(url.netloc)   
        conn.request("HEAD", url.path)
        res = conn.getresponse()
        return res.status, ourl
    except:
        return "error", ourl

def doSomethingWithResult(status, url):
    print status, url

q = Queue(concurrent * 2)
for i in range(concurrent):
    t = Thread(target=doWork)
    t.daemon = True
    t.start()
try:
    for url in open('urllist.txt'):
        q.put(url.strip())
    q.join()
except KeyboardInterrupt:
    sys.exit(1)

Це трохи швидше, ніж скручене рішення та використовує менше процесора.

Рішення за допомогою асинхронної мережевої бібліотеки торнадо

from tornado import ioloop, httpclient

i = 0

def handle_request(response):
    print(response.code)
    global i
    i -= 1
    if i == 0:
        ioloop.IOLoop.instance().stop()

http_client = httpclient.AsyncHTTPClient()
for url in open('urls.txt'):
    i += 1
    http_client.fetch(url.strip(), handle_request, method='HEAD')
ioloop.IOLoop.instance().start()

Речі змінилися досить сильно з 2010 року, коли це було опубліковано, і я не пробував всіх інших відповідей, але я спробував декілька, і я виявив, що це працює найкраще для мене за допомогою python3.6.

Мені вдалося отримати близько 150 унікальних доменів за секунду, що працює на AWS.

import pandas as pd
import concurrent.futures
import requests
import time

out = []
CONNECTIONS = 100
TIMEOUT = 5

tlds = open('../data/sample_1k.txt').read().splitlines()
urls = ['http://{}'.format(x) for x in tlds[1:]]

def load_url(url, timeout):
    ans = requests.head(url, timeout=timeout)
    return ans.status_code

with concurrent.futures.ThreadPoolExecutor(max_workers=CONNECTIONS) as executor:
    future_to_url = (executor.submit(load_url, url, TIMEOUT) for url in urls)
    time1 = time.time()
    for future in concurrent.futures.as_completed(future_to_url):
        try:
            data = future.result()
        except Exception as exc:
            data = str(type(exc))
        finally:
            out.append(data)

            print(str(len(out)),end="\r")

    time2 = time.time()

print(f'Took {time2-time1:.2f} s')
print(pd.Series(out).value_counts())

Нитки тут абсолютно не відповідь. Вони забезпечуватимуть як вузькі місця технологічних процесів, так і ядра, а також обмеження пропускної здатності, неприйнятні, якщо загальна мета - "найшвидший шлях".

Трохи twistedта його асинхронний HTTPклієнт дасть вам набагато кращі результати.

Я знаю, що це старе питання, але в Python 3.7 ви можете це зробити за допомогою asyncioі aiohttp.

import asyncio
import aiohttp
from aiohttp import ClientSession, ClientConnectorError

async def fetch_html(url: str, session: ClientSession, **kwargs) -> tuple:
    try:
        resp = await session.request(method="GET", url=url, **kwargs)
    except ClientConnectorError:
        return (url, 404)
    return (url, resp.status)

async def make_requests(urls: set, **kwargs) -> None:
    async with ClientSession() as session:
        tasks = []
        for url in urls:
            tasks.append(
                fetch_html(url=url, session=session, **kwargs)
            )
        results = await asyncio.gather(*tasks)

    for result in results:
        print(f'{result[1]} - {str(result[0])}')

if __name__ == "__main__":
    import pathlib
    import sys

    assert sys.version_info >= (3, 7), "Script requires Python 3.7+."
    here = pathlib.Path(__file__).parent

    with open(here.joinpath("urls.txt")) as infile:
        urls = set(map(str.strip, infile))

    asyncio.run(make_requests(urls=urls))

Ви можете прочитати більше про це та побачити приклад тут .

Скористайтеся вітальними повідомленнями , це комбінація запитів + ​​модуль Gevent.

GRequests дозволяє вам використовувати Запити з Gevent, щоб легко асинхронні запити HTTP.

Використання просте:

import grequests

urls = [
   'http://www.heroku.com',
   'http://tablib.org',
   'http://httpbin.org',
   'http://python-requests.org',
   'http://kennethreitz.com'
]

Створіть набір невиправлених запитів:

>>> rs = (grequests.get(u) for u in urls)

Надішліть їх одночасно:

>>> grequests.map(rs)
[<Response [200]>, <Response [200]>, <Response [200]>, <Response [200]>, <Response [200]>]

Хороший підхід до вирішення цієї проблеми полягає в тому, щоб спочатку написати код, необхідний для отримання одного результату, а потім включити нитку коду для паралелізації програми.

У ідеальному світі це просто означатиме одночасне започаткування 100 000 потоків, які виводять свої результати у словник або список для подальшої обробки, але на практиці ви обмежені тим, скільки паралельних запитів HTTP ви можете видати таким чином. Місцево, у вас є обмеження в тому, скільки сокет ви можете одночасно відкривати, скільки потоків виконання вашого інтерпретатора Python дозволить. Віддалено ви можете обмежитися кількістю одночасних з'єднань, якщо всі запити проти одного сервера або декількох. Ці обмеження, ймовірно, потребують того, що ви будете писати сценарій таким чином, щоб за один раз опитати лише невелику частину URL-адрес (100, як згадується інший плакат, - це, мабуть, пристойний розмір пулу потоків, хоча ви можете виявити, що ви може успішно розгорнути ще багато).

Ви можете дотримуватися цієї схеми дизайну, щоб вирішити вищевказану проблему:

1. Запустіть потік, який запускає нові потоки запитів, доки кількість поточних потоків, що виконуються в даний момент (ви можете відстежувати їх за допомогою threading.active_count () або шляхом натискання об'єктів потоку в структуру даних)>> ваша максимальна кількість одночасних запитів (скажімо, 100) , потім спить ненадовго. Цей потік повинен закінчуватися, коли більше URL-адрес обробляти не буде. Таким чином, нитка буде постійно прокидатися, запускати нові нитки і спати до тих пір, поки ваш не закінчиться.
2. Попросіть потоки запитів зберігати свої результати в деякій структурі даних для подальшого пошуку та виведення. Якщо структура, в якій ви зберігаєте результати, - це listабо dictв CPython, ви можете сміливо додавати або вставляти унікальні елементи зі своїх потоків без замків , але якщо ви записуєте у файл або потребуєте більш складної взаємодії даних міжпотокових даних, ви повинні використовувати блокування взаємного виключення для захисту цієї держави від корупції .

Я б запропонував вам використовувати модуль різьблення . Ви можете використовувати його для запуску та відстеження запущених потоків. Підтримка нитки Python є голою, але опис вашої проблеми говорить про те, що вона цілком достатня для ваших потреб.

І, нарешті, якщо ви хочете , щоб побачити досить просто додаток паралельного мережевого додатки , написаного в Python, перевірити ssh.py . Це невелика бібліотека, яка використовує потоки Python для паралелізації багатьох з'єднань SSH. Дизайн досить близький до ваших вимог, щоб ви могли вважати його хорошим ресурсом.

Якщо ви хочете отримати найкращу ефективність, можливо, вам варто скористатися асинхронним введенням-виведенням, а не потоками. Накладні витрати, пов’язані з тисячами потоків ОС, нетривіальні, і переключення контексту в інтерпретаторі Python додає ще більше. Нитка, безумовно, виконає роботу, але я підозрюю, що асинхронний маршрут забезпечить кращу загальну продуктивність.

Зокрема, я б запропонував веб-клієнт async у бібліотеці Twisted ( http://www.twistedmatrix.com ). Він має, безумовно, круту криву навчання, але він досить простий у використанні, як тільки ви отримаєте хорошу ручку в стилі асинхронного програмування Twisted.

API асинхронного веб-клієнта Twisted доступний за адресою:

http://twistedmatrix.com/documents/current/web/howto/client.html

Рішення:

from twisted.internet import reactor, threads
from urlparse import urlparse
import httplib
import itertools


concurrent = 200
finished=itertools.count(1)
reactor.suggestThreadPoolSize(concurrent)

def getStatus(ourl):
    url = urlparse(ourl)
    conn = httplib.HTTPConnection(url.netloc)   
    conn.request("HEAD", url.path)
    res = conn.getresponse()
    return res.status

def processResponse(response,url):
    print response, url
    processedOne()

def processError(error,url):
    print "error", url#, error
    processedOne()

def processedOne():
    if finished.next()==added:
        reactor.stop()

def addTask(url):
    req = threads.deferToThread(getStatus, url)
    req.addCallback(processResponse, url)
    req.addErrback(processError, url)   

added=0
for url in open('urllist.txt'):
    added+=1
    addTask(url.strip())

try:
    reactor.run()
except KeyboardInterrupt:
    reactor.stop()

Час випробування:

[kalmi@ubi1:~] wc -l urllist.txt
10000 urllist.txt
[kalmi@ubi1:~] time python f.py > /dev/null 

real    1m10.682s
user    0m16.020s
sys 0m10.330s
[kalmi@ubi1:~] head -n 6 urllist.txt
http://www.google.com
http://www.bix.hu
http://www.godaddy.com
http://www.google.com
http://www.bix.hu
http://www.godaddy.com
[kalmi@ubi1:~] python f.py | head -n 6
200 http://www.bix.hu
200 http://www.bix.hu
200 http://www.bix.hu
200 http://www.bix.hu
200 http://www.bix.hu
200 http://www.bix.hu

Pingtime:

bix.hu is ~10 ms away from me
godaddy.com: ~170 ms
google.com: ~30 ms

Використання пулу ниток - хороший варіант, і це зробить це досить просто. На жаль, у python не існує стандартної бібліотеки, яка робить пул потоків ультра легким. Але ось гідна бібліотека, з якою слід розпочати роботу: http://www.chrisarndt.de/projects/threadpool/

Приклад коду з їхнього сайту:

pool = ThreadPool(poolsize)
requests = makeRequests(some_callable, list_of_args, callback)
[pool.putRequest(req) for req in requests]
pool.wait()

Сподіваюсь, це допомагає.

Створіть epollоб'єкт,
відкрийте багато клієнтських сокетів TCP,
налаштуйте їх буфери відправлення, щоб бути трохи більше, ніж заголовок запиту,
надішліть заголовок запиту - він повинен бути негайним, просто помістити в буфер, зареєструвати сокет в epollоб’єкті,
зробити .pollна предмет epoll,
прочитати спочатку 3 байтів з кожного сокета з .poll,
запишіть їх, щоб sys.stdoutдалі\n (не змивайте), закрийте клієнтський сокет.

Обмежте кількість розеток одночасно відкритих - обробляйте помилки, коли створюються сокети. Створіть нову розетку, лише якщо інша закрита.
Налаштування лімітів ОС.
Спробуйте роздрібнити декілька (не багато) процесів: це може допомогти використовувати процесор трохи ефективніше.

У вашому випадку, нарізання різьби, ймовірно, зробить трюк, оскільки ви, ймовірно, будете витрачати більшість часу на очікування відповіді. У стандартній бібліотеці є корисні модулі на зразок черги, які можуть допомогти.

Я робив подібну річ з паралельним завантаженням файлів і раніше, і це було досить добре для мене, але це було не в масштабі, про який ви говорите.

Якщо ваше завдання було більше пов'язане з процесором, ви можете подивитися модуль багатопроцесорної обробки , який дозволить вам використовувати більше процесорів / ядер / потоків (більше процесів, які не блокують один одного, оскільки блокування відбувається за один процес)

Подумайте про використання вітряної млини , хоча вітряк, мабуть, не може зробити це багатьма нитками.

Ви можете зробити це за допомогою ручного прокату Python-скрипту на 5 машинах, кожен з яких з'єднує вихідний за допомогою портів 40000-60000, відкриваючи 100 000 підключень до порту.

Крім того, це може допомогти зробити зразковий тест із чудово втіленою програмою QA, такою як OpenSTA , щоб отримати уявлення про те, наскільки може працювати кожен сервер.

Крім того, спробуйте розглянути просто використання Perl з класом LWP :: ConnCache. Ви, ймовірно, отримаєте більшу продуктивність (більше підключень) таким чином.

Цей закручений веб-клієнт async проходить досить швидко.

#!/usr/bin/python2.7

from twisted.internet import reactor
from twisted.internet.defer import Deferred, DeferredList, DeferredLock
from twisted.internet.defer import inlineCallbacks
from twisted.web.client import Agent, HTTPConnectionPool
from twisted.web.http_headers import Headers
from pprint import pprint
from collections import defaultdict
from urlparse import urlparse
from random import randrange
import fileinput

pool = HTTPConnectionPool(reactor)
pool.maxPersistentPerHost = 16
agent = Agent(reactor, pool)
locks = defaultdict(DeferredLock)
codes = {}

def getLock(url, simultaneous = 1):
    return locks[urlparse(url).netloc, randrange(simultaneous)]

@inlineCallbacks
def getMapping(url):
    # Limit ourselves to 4 simultaneous connections per host
    # Tweak this number, but it should be no larger than pool.maxPersistentPerHost 
    lock = getLock(url,4)
    yield lock.acquire()
    try:
        resp = yield agent.request('HEAD', url)
        codes[url] = resp.code
    except Exception as e:
        codes[url] = str(e)
    finally:
        lock.release()


dl = DeferredList(getMapping(url.strip()) for url in fileinput.input())
dl.addCallback(lambda _: reactor.stop())

reactor.run()
pprint(codes)

Я виявив, що використання tornadoпакету - це найшвидший і найпростіший спосіб досягти цього:

from tornado import ioloop, httpclient, gen


def main(urls):
    """
    Asynchronously download the HTML contents of a list of URLs.
    :param urls: A list of URLs to download.
    :return: List of response objects, one for each URL.
    """

    @gen.coroutine
    def fetch_and_handle():
        httpclient.AsyncHTTPClient.configure(None, defaults=dict(user_agent='MyUserAgent'))
        http_client = httpclient.AsyncHTTPClient()
        waiter = gen.WaitIterator(*[http_client.fetch(url, raise_error=False, method='HEAD')
                                    for url in urls])
        results = []
        # Wait for the jobs to complete
        while not waiter.done():
            try:
                response = yield waiter.next()
            except httpclient.HTTPError as e:
                print(f'Non-200 HTTP response returned: {e}')
                continue
            except Exception as e:
                print(f'An unexpected error occurred querying: {e}')
                continue
            else:
                print(f'URL \'{response.request.url}\' has status code <{response.code}>')
                results.append(response)
        return results

    loop = ioloop.IOLoop.current()
    web_pages = loop.run_sync(fetch_and_handle)

    return web_pages

my_urls = ['url1.com', 'url2.com', 'url100000.com']
responses = main(my_urls)
print(responses[0])

Найпростішим способом було б користуватися вбудованою бібліотекою різьблення Python. Вони не є "справжніми" / потоками ядра. У них є проблеми (як серіалізація), але вони досить хороші. Ви хочете пула черг та ниток. Один варіант є тут , але тривіально написати власний. Ви не можете паралельно виконати всі 100 000 дзвінків, але ви можете одночасно відмовитись від 100 (або близько) з них.