Quel est le moyen le plus rapide d'envoyer 100 000 requêtes HTTP en Python?

J'ouvre un fichier contenant 100 000 URL. Je dois envoyer une demande HTTP à chaque URL et imprimer le code d'état. J'utilise Python 2.6, et jusqu'à présent, j'ai examiné les nombreuses façons confuses que Python implémente le threading / simultanéité. J'ai même regardé la bibliothèque de concours python , mais je ne sais pas comment écrire correctement ce programme. Quelqu'un a-t-il rencontré un problème similaire? Je suppose qu'en général, j'ai besoin de savoir comment effectuer des milliers de tâches en Python aussi rapidement que possible - je suppose que cela signifie «simultanément».

Solution sans torsion:

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)

Celui-ci est légèrement plus rapide que la solution torsadée et utilise moins de CPU.

Une solution utilisant la bibliothèque de mise en réseau asynchrone 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()

Les choses ont beaucoup changé depuis 2010, lorsque cela a été publié et je n'ai pas essayé toutes les autres réponses, mais j'en ai essayé quelques-unes, et j'ai trouvé que cela fonctionnait le mieux pour moi en utilisant python3.6.

J'ai pu récupérer environ 150 domaines uniques par seconde sur 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())

Les discussions ne sont absolument pas la réponse ici. Ils fourniront à la fois des goulots d'étranglement de processus et de noyau, ainsi que des limites de débit qui ne sont pas acceptables si l'objectif global est "le moyen le plus rapide".

Un peu de twistedet son HTTPclient asynchrone vous donneraient de bien meilleurs résultats.

Je sais que c'est une vieille question, mais en Python 3.7 vous pouvez le faire en utilisant asyncioet 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))

Vous pouvez en savoir plus à ce sujet et voir un exemple ici .

Utilisez les grequests , c'est une combinaison de requêtes + module Gevent.

GRequests vous permet d'utiliser des requêtes avec Gevent pour créer facilement des requêtes HTTP asynchrones.

L'utilisation est simple:

import grequests

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

Créez un ensemble de demandes non envoyées:

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

Envoyez-les tous en même temps:

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

Une bonne approche pour résoudre ce problème consiste à écrire d'abord le code requis pour obtenir un résultat, puis à incorporer du code de thread pour paralléliser l'application.

Dans un monde parfait, cela signifierait simplement démarrer simultanément 100 000 threads qui produisent leurs résultats dans un dictionnaire ou une liste pour un traitement ultérieur, mais en pratique, vous êtes limité dans le nombre de requêtes HTTP parallèles que vous pouvez émettre de cette manière. Localement, vous avez des limites dans le nombre de sockets que vous pouvez ouvrir simultanément, le nombre de threads d'exécution autorisés par votre interpréteur Python. À distance, le nombre de connexions simultanées peut être limité si toutes les demandes concernent un ou plusieurs serveurs. Ces limitations nécessiteront probablement que vous écriviez le script de manière à interroger uniquement une petite fraction des URL à la fois (100, comme une autre affiche l'a mentionné, est probablement une taille de pool de threads décente, bien que vous puissiez constater que vous peut déployer avec succès beaucoup plus).

Vous pouvez suivre ce modèle de conception pour résoudre le problème ci-dessus:

1. Démarrez un thread qui lance de nouveaux threads de demande jusqu'à ce que le nombre de threads en cours d'exécution (vous pouvez les suivre via threading.active_count () ou en poussant les objets de thread dans une structure de données) est> = votre nombre maximal de requêtes simultanées (par exemple 100) , puis s'endort brièvement. Ce fil devrait se terminer lorsqu'il n'y a plus d'URL à traiter. Ainsi, le thread continuera à se réveiller, à lancer de nouveaux threads et à dormir jusqu'à ce que vous ayez terminé.
2. Demandez aux threads de demande de stocker leurs résultats dans une certaine structure de données pour une récupération et une sortie ultérieures. Si la structure dans laquelle vous stockez les résultats est un listou dictdans CPython, vous pouvez ajouter ou insérer en toute sécurité des éléments uniques de vos threads sans verrous , mais si vous écrivez dans un fichier ou si vous avez besoin d'une interaction de données cross-thread plus complexe, vous devez utiliser un verrouillage d'exclusion mutuelle pour protéger cet état de la corruption .

Je vous suggère d'utiliser le module de threading . Vous pouvez l'utiliser pour lancer et suivre les threads en cours d'exécution. Le support de threading de Python est nu, mais la description de votre problème suggère qu'il est complètement suffisant pour vos besoins.

Enfin, si vous souhaitez voir une application assez simple d'une application de réseau parallèle écrit en Python, consultez ssh.py . Il s'agit d'une petite bibliothèque qui utilise le threading Python pour paralléliser de nombreuses connexions SSH. La conception est suffisamment proche de vos besoins pour que vous puissiez la trouver comme une bonne ressource.

Si vous cherchez à obtenir les meilleures performances possibles, vous pouvez envisager d'utiliser des E / S asynchrones plutôt que des threads. La surcharge associée à des milliers de threads du système d'exploitation n'est pas anodine et le changement de contexte dans l'interpréteur Python en ajoute encore plus. Le filetage fera certainement l'affaire, mais je soupçonne qu'un itinéraire asynchrone fournira de meilleures performances globales.

Plus précisément, je suggère le client Web asynchrone dans la bibliothèque Twisted ( http://www.twistedmatrix.com ). Il a certes une courbe d'apprentissage abrupte mais il est assez facile à utiliser une fois que vous maîtrisez le style de programmation asynchrone de Twisted.

Un HowTo sur l'API client Web asynchrone de Twisted est disponible à l'adresse suivante:

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

Une solution:

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

Temps de test:

[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'utilisation d'un pool de threads est une bonne option et rendra cela assez facile. Malheureusement, python n'a pas de bibliothèque standard qui rend les pools de threads ultra faciles. Mais voici une bibliothèque décente qui devrait vous aider à démarrer: http://www.chrisarndt.de/projects/threadpool/

Exemple de code de leur site:

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

J'espère que cela t'aides.

Créez un epollobjet,
ouvrez de nombreuses sockets TCP client,
ajustez leurs tampons d'envoi pour être un peu plus que l'en-tête de demande,
envoyez un en-tête de demande - cela devrait être immédiat, il suffit de le placer dans un tampon, d'enregistrer le socket dans l' epollobjet, de le
faire .pollsur epollobect, de
lire en premier 3 octets de chaque socket .poll,
écrivez-les sys.stdoutpuis\n (ne pas vider), fermez le socket client.

Limitez le nombre de sockets ouvertes simultanément - gérez les erreurs lors de la création de sockets. Créez un nouveau socket uniquement si un autre est fermé.
Ajustez les limites du système d'exploitation.
Essayez de vous lancer dans quelques (peu) processus: cela peut aider à utiliser le processeur un peu plus efficacement.

Pour votre cas, le filetage fera probablement l'affaire, car vous passerez probablement le plus de temps à attendre une réponse. Il existe des modules utiles comme Queue dans la bibliothèque standard qui pourraient vous aider.

J'ai fait une chose similaire avec le téléchargement parallèle de fichiers auparavant et c'était assez bon pour moi, mais ce n'était pas à l'échelle dont vous parlez.

Si votre tâche était plus liée au CPU, vous voudrez peut-être regarder le module multiprocessing , qui vous permettra d'utiliser plus de CPU / cores / threads (plus de processus qui ne se bloqueront pas puisque le verrouillage est par processus)

Pensez à utiliser Windmill , bien que Windmill ne puisse probablement pas faire autant de threads.

Vous pouvez le faire avec un script Python roulé à la main sur 5 machines, chacune se connectant sortante à l'aide des ports 40000-60000, ouvrant 100 000 connexions de port.

En outre, il peut être utile de faire un exemple de test avec une application d'assurance qualité bien filetée telle que OpenSTA afin de se faire une idée de la capacité de chaque serveur.

Aussi, essayez de regarder simplement en utilisant Perl simple avec la classe LWP :: ConnCache. Vous obtiendrez probablement plus de performances (plus de connexions) de cette façon.

Ce client Web asynchrone tordu va assez vite.

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

J'ai trouvé que l'utilisation du tornadopackage était le moyen le plus rapide et le plus simple d'y parvenir:

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

La manière la plus simple serait d'utiliser la bibliothèque de threads intégrée de Python. Ce ne sont pas de «vrais» threads / noyau Ils ont des problèmes (comme la sérialisation), mais sont assez bons. Vous souhaitez un pool de files d'attente et de threads. Une option est ici , mais il est trivial d'écrire la vôtre. Vous ne pouvez pas paralléliser tous les 100 000 appels, mais vous pouvez en lancer 100 (ou plus) en même temps.