Was ist der schnellste Weg, um 100.000 HTTP-Anfragen in Python zu senden?

Ich öffne eine Datei mit 100.000 URLs. Ich muss eine HTTP-Anfrage an jede URL senden und den Statuscode drucken. Ich verwende Python 2.6 und habe mir bisher die vielen verwirrenden Möglichkeiten angesehen, wie Python Threading / Parallelität implementiert. Ich habe mir sogar die Python- Concurrence- Bibliothek angesehen, kann aber nicht herausfinden, wie man dieses Programm richtig schreibt. Ist jemand auf ein ähnliches Problem gestoßen? Ich denke, im Allgemeinen muss ich wissen, wie man Tausende von Aufgaben in Python so schnell wie möglich ausführt - ich nehme an, das bedeutet "gleichzeitig".

Verdrehte Lösung:

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)

Dieser ist etwas schneller als die verdrehte Lösung und verbraucht weniger CPU.

Eine Lösung mit asynchroner Tornado- Netzwerkbibliothek

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

Die Dinge haben sich seit 2010, als dies veröffentlicht wurde, ziemlich verändert und ich habe nicht alle anderen Antworten ausprobiert, aber ich habe einige ausprobiert, und ich fand, dass dies mit Python3.6 am besten für mich funktioniert.

Ich konnte ungefähr 150 eindeutige Domänen pro Sekunde abrufen, die unter AWS ausgeführt wurden.

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

Themen sind hier absolut nicht die Antwort. Sie bieten sowohl Prozess- als auch Kernel-Engpässe sowie Durchsatzbeschränkungen, die nicht akzeptabel sind, wenn das Gesamtziel "der schnellste Weg" ist.

Ein bisschen twistedund sein asynchroner HTTPClient würden Ihnen viel bessere Ergebnisse liefern.

Ich weiß, dass dies eine alte Frage ist, aber in Python 3.7 können Sie dies mit asynciound tun 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))

Sie können mehr darüber lesen und hier ein Beispiel sehen .

Verwenden Sie Grequests , es ist eine Kombination aus Anforderungen + Gevent-Modul.

Mit GRequests können Sie Requests with Gevent verwenden, um auf einfache Weise asynchrone HTTP-Requests zu erstellen.

Die Verwendung ist einfach:

import grequests

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

Erstellen Sie eine Reihe nicht gesendeter Anfragen:

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

Senden Sie sie alle gleichzeitig:

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

Ein guter Ansatz zur Lösung dieses Problems besteht darin, zuerst den Code zu schreiben, der erforderlich ist, um ein Ergebnis zu erhalten, und dann Threading-Code zu integrieren, um die Anwendung zu parallelisieren.

In einer perfekten Welt würde dies einfach bedeuten, gleichzeitig 100.000 Threads zu starten, die ihre Ergebnisse zur späteren Verarbeitung in ein Wörterbuch oder eine Liste ausgeben. In der Praxis ist die Anzahl der parallelen HTTP-Anforderungen, die Sie auf diese Weise ausgeben können, jedoch begrenzt. Lokal haben Sie Grenzen, wie viele Sockets Sie gleichzeitig öffnen können und wie viele Ausführungsthreads Ihr Python-Interpreter zulässt. Aus der Ferne kann die Anzahl der gleichzeitigen Verbindungen begrenzt sein, wenn alle Anforderungen an einen oder mehrere Server gerichtet sind. Diese Einschränkungen erfordern wahrscheinlich, dass Sie das Skript so schreiben, dass jeweils nur ein kleiner Teil der URLs abgefragt wird (100, wie in einem anderen Poster erwähnt, sind wahrscheinlich eine anständige Größe des Thread-Pools, obwohl Sie dies möglicherweise feststellen kann erfolgreich viele weitere bereitstellen).

Sie können diesem Entwurfsmuster folgen, um das obige Problem zu beheben:

1. Starten Sie einen Thread, der neue Anforderungsthreads startet, bis die Anzahl der aktuell ausgeführten Threads (Sie können sie über threading.active_count () oder durch Verschieben der Threadobjekte in eine Datenstruktur verfolgen)> = Ihre maximale Anzahl gleichzeitiger Anforderungen ist (z. B. 100). , schläft dann für eine kurze Auszeit. Dieser Thread sollte beendet werden, wenn keine URLs mehr verarbeitet werden müssen. Auf diese Weise wacht der Thread weiter auf, startet neue Threads und schläft, bis Sie fertig sind.
2. Lassen Sie die Anforderungsthreads ihre Ergebnisse in einer Datenstruktur speichern, um sie später abzurufen und auszugeben. Wenn die Struktur, in der Sie die Ergebnisse speichern, a listoder dictin CPython ist, können Sie eindeutige Elemente ohne Sperren sicher an Ihre Threads anhängen oder einfügen. Wenn Sie jedoch in eine Datei schreiben oder eine komplexere threadübergreifende Dateninteraktion benötigen , sollten Sie a verwenden gegenseitige Ausschlusssperre zum Schutz dieses Staates vor Korruption .

Ich würde vorschlagen, dass Sie das Threading verwenden Modul verwenden. Sie können es verwenden, um laufende Threads zu starten und zu verfolgen. Die Threading-Unterstützung von Python ist kahl, aber die Beschreibung Ihres Problems legt nahe, dass sie für Ihre Anforderungen völlig ausreichend ist.

Wenn Sie würde schließlich wie eine ziemlich einfache Anwendung eines parallelen Netzwerk - Anwendung in Python geschrieben sehen, die ssh.py . Es ist eine kleine Bibliothek, die Python-Threading verwendet, um viele SSH-Verbindungen zu parallelisieren. Das Design ist nah genug an Ihren Anforderungen, sodass Sie es möglicherweise als gute Ressource ansehen.

Wenn Sie die bestmögliche Leistung erzielen möchten, sollten Sie die Verwendung von asynchronen E / A anstelle von Threads in Betracht ziehen. Der mit Tausenden von Betriebssystem-Threads verbundene Overhead ist nicht trivial, und die Kontextumschaltung innerhalb des Python-Interpreters fügt noch mehr hinzu. Das Threading wird sicherlich die Arbeit erledigen, aber ich vermute, dass eine asynchrone Route eine bessere Gesamtleistung bietet.

Insbesondere würde ich den asynchronen Webclient in der Twisted-Bibliothek ( http://www.twistedmatrix.com ) vorschlagen . Es hat eine zugegebenermaßen steile Lernkurve, ist aber recht einfach zu bedienen, wenn Sie Twisted's asynchronen Programmierstil gut im Griff haben.

Eine Anleitung zur asynchronen Webclient-API von Twisted finden Sie unter:

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

Eine Lösung:

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

Testzeit:

[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

Die Verwendung eines Thread-Pools ist eine gute Option und macht dies ziemlich einfach. Leider verfügt Python nicht über eine Standardbibliothek, die Thread-Pools extrem einfach macht. Aber hier ist eine anständige Bibliothek, die Ihnen den Einstieg erleichtern soll: http://www.chrisarndt.de/projects/threadpool/

Codebeispiel von ihrer Site:

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

Hoffe das hilft.

Erstellen epoll Objekt,
öffnen viele Client - TCP - Sockets,
passen ihre Sendepuffer ein bisschen mehr als Request - Header zu sein,
einen Request - Header senden - es sollte sofort sein, nur in einen Puffer platzieren, registriert Buchse in dem epollObjekt,
tut .pollauf epollObect,
zuerst lesen 3 Bytes von jedem Socket aus .poll,
schreiben Sie sie sys.stdoutgefolgt von \n(nicht leeren), schließen Sie den Client-Socket.

Begrenzen Sie die Anzahl der gleichzeitig geöffneten Sockets. Behandeln Sie Fehler beim Erstellen von Sockets. Erstellen Sie einen neuen Socket nur, wenn ein anderer geschlossen ist.
Passen Sie die Betriebssystemgrenzen an.
Versuchen Sie, einige (nicht viele) Prozesse zu bearbeiten: Dies kann dazu beitragen, die CPU ein wenig effektiver zu nutzen.

In Ihrem Fall reicht das Threading wahrscheinlich aus, da Sie wahrscheinlich die meiste Zeit damit verbringen, auf eine Antwort zu warten. Es gibt hilfreiche Module wie Queue in der Standardbibliothek, die möglicherweise helfen.

Ähnliches habe ich beim parallelen Herunterladen von Dateien gemacht, und es war gut genug für mich, aber es war nicht in der Größenordnung, von der Sie sprechen.

Wenn Ihre Aufgabe stärker an die CPU gebunden war, sollten Sie sich das Multiprozessor- Modul ansehen, mit dem Sie mehr CPUs / Kerne / Threads verwenden können (mehr Prozesse, die sich nicht gegenseitig blockieren, da die Sperrung pro Prozess erfolgt).

Erwägen Sie die Verwendung von Windmill , obwohl Windmill wahrscheinlich nicht so viele Threads ausführen kann.

Sie können dies mit einem handgerollten Python-Skript auf 5 Computern tun, von denen jeder über die Ports 40000-60000 eine ausgehende Verbindung herstellt und 100.000 Portverbindungen öffnet.

Es kann auch hilfreich sein, einen Beispieltest mit einer QA-App wie OpenSTA durchzuführen, um eine Vorstellung davon zu bekommen, wie viel jeder Server verarbeiten kann.

Versuchen Sie auch, nur einfaches Perl mit der LWP :: ConnCache-Klasse zu verwenden. Auf diese Weise erhalten Sie wahrscheinlich mehr Leistung (mehr Verbindungen).

Dieser verdrehte asynchrone Webclient geht ziemlich schnell.

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

Ich fand, dass die Verwendung des tornadoPakets der schnellste und einfachste Weg ist, dies zu erreichen:

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

Am einfachsten wäre es, die in Python integrierte Threading-Bibliothek zu verwenden. Sie sind keine "echten" / Kernel-Threads. Sie haben Probleme (wie die Serialisierung), sind aber gut genug. Sie möchten einen Warteschlangen- und Thread-Pool. Eine Option ist hier , aber es ist trivial, eigene zu schreiben. Sie können nicht alle 100.000 Anrufe parallelisieren, aber Sie können 100 (oder so) gleichzeitig abfeuern.