Qual è il modo più veloce per inviare 100.000 richieste HTTP in Python?

Sto aprendo un file con 100.000 URL. Devo inviare una richiesta HTTP a ciascun URL e stampare il codice di stato. Sto usando Python 2.6 e finora ho esaminato i molti modi confusi in cui Python implementa il threading / la concorrenza. Ho anche dato un'occhiata alla libreria di concurrence di Python , ma non riesco a capire come scrivere correttamente questo programma. Qualcuno ha riscontrato un problema simile? Immagino che in genere devo sapere come eseguire migliaia di attività in Python il più velocemente possibile - suppongo che significhi "contemporaneamente".

Soluzione Twistedless:

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)

Questo è leggermente più veloce della soluzione twistata e utilizza meno CPU.

Una soluzione che utilizza la libreria di rete asincrona di tornado

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()

Le cose sono cambiate un po 'dal 2010, quando questo è stato pubblicato e non ho provato tutte le altre risposte, ma ne ho provate alcune e ho trovato che funziona meglio con me usando python3.6.

Sono stato in grado di recuperare circa 150 domini unici al secondo in esecuzione su 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())

Le discussioni non sono assolutamente la risposta qui. Forniranno colli di bottiglia sia del processo che del kernel, nonché limiti di velocità che non sono accettabili se l'obiettivo generale è "il modo più veloce".

Un po 'di twistede il suo HTTPclient asincrono ti darebbe risultati molto migliori.

So che questa è una vecchia domanda, ma in Python 3.7 puoi farlo usando asyncioe 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))

Puoi leggere di più a riguardo e vedere un esempio qui .

Usa grequests , è una combinazione di richieste + modulo Gevent.

GRequests ti consente di utilizzare le richieste con Gevent per rendere facilmente richieste HTTP asincrone.

L'uso è semplice:

import grequests

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

Crea una serie di richieste non inviate:

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

Inviali tutti contemporaneamente:

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

Un buon approccio per risolvere questo problema è innanzitutto scrivere il codice richiesto per ottenere un risultato, quindi incorporare il threading code per parallelizzare l'applicazione.

In un mondo perfetto ciò significherebbe semplicemente avviare simultaneamente 100.000 thread che generano i loro risultati in un dizionario o in un elenco per l'elaborazione successiva, ma in pratica si è limitati a quante richieste HTTP parallele è possibile inviare in questo modo. A livello locale, hai dei limiti su quanti socket puoi aprire contemporaneamente, quanti thread di esecuzione consentirà il tuo interprete Python. In remoto, potresti avere un numero limitato di connessioni simultanee se tutte le richieste sono indirizzate a un server o a molte. Queste limitazioni probabilmente richiederanno che tu scriva lo script in modo da eseguire il polling solo una piccola parte degli URL in qualsiasi momento (100, come menzionato da un altro poster, è probabilmente una dimensione del pool di thread decente, anche se potresti scoprire che tu può implementare con successo molti altri).

È possibile seguire questo modello di progettazione per risolvere il problema sopra riportato:

1. Avvia un thread che avvia nuovi thread di richieste fino a quando il numero di thread attualmente in esecuzione (puoi seguirli tramite threading.active_count () o spingendo gli oggetti thread in una struttura di dati) è> = il tuo numero massimo di richieste simultanee (diciamo 100) , quindi dorme per un breve timeout. Questo thread dovrebbe terminare quando non ci sono più URL da elaborare. Pertanto, il thread continuerà a svegliarsi, lanciando nuovi thread e dormendo fino al termine.
2. Chiedi ai thread di richiesta di archiviare i loro risultati in una struttura di dati per il successivo recupero e output. Se la struttura in cui si stanno archiviando i risultati è a listo dictin CPython, è possibile aggiungere o inserire in modo sicuro elementi univoci dai thread senza blocchi , ma se si scrive su un file o si richiede un'interazione tra thread più complessa, è necessario utilizzare un blocco di esclusione reciproca per proteggere questo stato dalla corruzione .

Vorrei suggerire di utilizzare il modulo di threading . Puoi usarlo per avviare e tenere traccia dei thread in esecuzione. Il supporto per il threading di Python è semplice, ma la descrizione del tuo problema suggerisce che è completamente sufficiente per le tue esigenze.

Infine, se si desidera vedere una bella semplice applicazione di un'applicazione di rete in parallelo scritto in Python, controlla ssh.py . È una piccola libreria che utilizza il threading Python per parallelizzare molte connessioni SSH. Il design è abbastanza vicino alle tue esigenze che potresti trovare una buona risorsa.

Se stai cercando di ottenere le migliori prestazioni possibili, potresti prendere in considerazione l'uso dell'I / O asincrono anziché i thread. Il sovraccarico associato a migliaia di thread del sistema operativo non è banale e il cambio di contesto all'interno dell'interprete Python ne aggiunge ancora di più. Il threading farà sicuramente il suo lavoro, ma sospetto che un percorso asincrono fornirà migliori prestazioni complessive.

In particolare, suggerirei il client Web asincrono nella libreria Twisted ( http://www.twistedmatrix.com ). Ha una curva di apprendimento certamente ripida, ma è abbastanza facile da usare quando si ha una buona conoscenza dello stile di programmazione asincrona di Twisted.

Un HowTo sull'API del client Web asincrono di Twisted è disponibile all'indirizzo:

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

Una soluzione:

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()

Testtime:

[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

L'uso di un pool di thread è una buona opzione e lo renderà abbastanza semplice. Sfortunatamente, python non ha una libreria standard che rende i pool di thread ultra facili. Ma ecco una biblioteca decente che dovrebbe iniziare: http://www.chrisarndt.de/projects/threadpool/

Esempio di codice dal loro sito:

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

Spero che questo ti aiuti.

Crea epolloggetto,
apri molti socket TCP client,
regola i loro buffer di invio in modo che siano un po 'più di un'intestazione di richiesta,
invia un'intestazione di richiesta - dovrebbe essere immediato, semplicemente inserendo un buffer, registra un socket epollnell'oggetto,
fai .pollsu epollobect,
leggi prima 3 byte da ciascun socket da .poll,
scriverli a sys.stdoutseguiti da \n(non svuotare), chiudere il socket client.

Limitare il numero di socket aperti contemporaneamente: gestire gli errori durante la creazione dei socket. Crea un nuovo socket solo se un altro è chiuso.
Regola i limiti del sistema operativo.
Prova a fare il fork di alcuni (non molti) processi: questo potrebbe aiutare a utilizzare la CPU in modo un po 'più efficace.

Nel tuo caso, il threading probabilmente farà il trucco poiché probabilmente passerai la maggior parte del tempo in attesa di una risposta. Ci sono moduli utili come Queue nella libreria standard che potrebbero aiutare.

Ho fatto una cosa simile con il download parallelo di file prima ed è stato abbastanza buono per me, ma non era sulla scala di cui stai parlando.

Se la tua attività fosse più legata alla CPU, potresti voler esaminare il modulo multiprocessore , che ti permetterà di utilizzare più CPU / core / thread (più processi che non si bloccano a vicenda poiché il blocco è per processo)

Prendi in considerazione l'utilizzo di Windmill , anche se probabilmente Windmill non è in grado di fare così tanti thread.

Potresti farlo con uno script Python arrotolato a mano su 5 macchine, ognuna connessa in uscita usando le porte 40000-60000, aprendo 100.000 connessioni di porte.

Inoltre, potrebbe essere utile eseguire un test di esempio con un'app QA ben strutturata come OpenSTA per avere un'idea di quanto ogni server può gestire.

Inoltre, prova a guardare semplicemente usando Perl semplice con la classe LWP :: ConnCache. Probabilmente otterrai più prestazioni (più connessioni) in questo modo.

Questo contorto client Web asincrono va piuttosto veloce.

#!/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)

Ho scoperto che l'utilizzo del tornadopacchetto è il modo più rapido e semplice per raggiungere questo obiettivo:

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])

Il modo più semplice sarebbe utilizzare la libreria di threading integrata di Python. Non sono "reali" / thread del kernel Hanno problemi (come la serializzazione), ma sono abbastanza buoni. Vorresti un pool di code e thread. Un'opzione è qui , ma è banale scriverne una tua. Non è possibile parallelizzare tutte le 100.000 chiamate, ma è possibile attivarne 100 (o giù di lì) contemporaneamente.